This required a somewhat more substantial include reshuffling.
Some typedefs have been moved to gtkiconfactory.h and to
gtksettings.h.
deprecated/gtkhscale.h \
deprecated/gtkhscrollbar.h \
deprecated/gtkhseparator.h \
+ deprecated/gtkstyle.h \
+ deprecated/gtkrc.h \
deprecated/gtktable.h \
deprecated/gtktearoffmenuitem.h \
deprecated/gtkvbbox.h \
gtkradiomenuitem.h \
gtkradiotoolbutton.h \
gtkrange.h \
- gtkrc.h \
gtkrecentaction.h \
gtkrecentchooser.h \
gtkrecentchooserdialog.h \
gtkstylecontext.h \
gtkstyleproperties.h \
gtkstyleprovider.h \
- gtkstyle.h \
gtkswitch.h \
gtksymboliccolor.h \
gtktestutils.h \
deprecated/gtkhscale.c \
deprecated/gtkhscrollbar.c \
deprecated/gtkhseparator.c \
+ deprecated/gtkrc.c \
+ deprecated/gtkstyle.c \
deprecated/gtktable.c \
deprecated/gtktearoffmenuitem.c \
deprecated/gtkvbbox.c \
gtkradiotoolbutton.c \
gtkrange.c \
gtkrbtree.c \
- gtkrc.c \
gtkrecentaction.c \
gtkrecentchooserdefault.c \
gtkrecentchooserdialog.c \
gtkstyleproperties.c \
gtkstyleproperty.c \
gtkstyleprovider.c \
- gtkstyle.c \
gtkswitch.c \
gtksymboliccolor.c \
gtktestutils.c \
-I$(top_builddir)/gtk \
-DGTK_VERSION=\"$(GTK_VERSION)\"\
-DGTK_COMPILATION \
- -DGDK_DISABLE_DEPRECATED \
- -DGTK_DISABLE_DEPRECATED \
$(AM_CPPFLAGS)
libgail_la_CFLAGS = \
#include <gdk/gdk.h>
#include <gtk/gtkx.h>
+#include <gtk/gtkentry.h>
+#include <gtk/gtknotebook.h>
+#include <gtk/gtkmenuitem.h>
+#include <gtk/gtkmenu.h>
+#include <gtk/gtkmenubar.h>
+#include <gtk/gtktogglebutton.h>
+#include <gtk/gtkcombobox.h>
+#include <gtk/gtkaccessible.h>
#include "gailutil.h"
#include "gailmisc.h"
#include <string.h>
#include <gtk/gtkx.h>
+#include <gtk/gtkeventbox.h>
+#include <gtk/gtkscrolledwindow.h>
+#include <gtk/gtkframe.h>
+#include <gtk/gtkmenu.h>
+#include <gtk/gtkmenuitem.h>
+#include <gtk/gtkbutton.h>
#include "gtktoplevelaccessible.h"
--- /dev/null
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
+ * file for a list of people on the GTK+ Team. See the ChangeLog
+ * files for a list of changes. These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
+ */
+
+#include "config.h"
+
+#include <locale.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#include <sys/stat.h>
+#ifdef HAVE_SYS_PARAM_H
+#include <sys/param.h>
+#endif
+#include <fcntl.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+
+#include <glib.h>
+#include <glib/gstdio.h>
+#include "gdk/gdk.h"
+
+#include "gtkversion.h"
+#include "gtkrc.h"
+#include "gtkstyle.h"
+#include "gtkbindings.h"
+#include "gtkintl.h"
+#include "gtkiconfactory.h"
+#include "gtkmain.h"
+#include "gtkmodules.h"
+#include "gtkmodulesprivate.h"
+#include "gtkprivate.h"
+#include "gtksettingsprivate.h"
+#include "gtkwindow.h"
+
+#ifdef G_OS_WIN32
+#include <io.h>
+#endif
+
+
+/**
+ * SECTION:gtkrc
+ * @Short_description: Deprecated routines for handling resource files
+ * @Title: Resource Files
+ *
+ * GTK+ provides resource file mechanism for configuring
+ * various aspects of the operation of a GTK+ program
+ * at runtime.
+ *
+ * <warning>
+ * In GTK+ 3.0, resource files have been deprecated and replaced
+ * by CSS-like style sheets, which are understood by #GtkCssProvider.
+ * </warning>
+ *
+ * <refsect2>
+ * <title>Default files</title>
+ * <para>
+ * An application can cause GTK+ to parse a specific RC
+ * file by calling gtk_rc_parse(). In addition to this,
+ * certain files will be read at the end of gtk_init().
+ * Unless modified, the files looked for will be
+ * <filename><SYSCONFDIR>/gtk-2.0/gtkrc</filename>
+ * and <filename>.gtkrc-3.0</filename> in the users home directory.
+ * (<filename><SYSCONFDIR></filename> defaults to
+ * <filename>/usr/local/etc</filename>. It can be changed with the
+ * <option>--prefix</option> or <option>--sysconfdir</option> options when
+ * configuring GTK+.)
+ *
+ * The set of these <firstterm>default</firstterm> files
+ * can be retrieved with gtk_rc_get_default_files()
+ * and modified with gtk_rc_add_default_file() and
+ * gtk_rc_set_default_files().
+ * Additionally, the <envar>GTK2_RC_FILES</envar> environment variable
+ * can be set to a #G_SEARCHPATH_SEPARATOR_S-separated list of files
+ * in order to overwrite the set of default files at runtime.
+ * <para><anchor id="locale-specific-rc"/>
+ * For each RC file, in addition to the file itself, GTK+ will look for
+ * a locale-specific file that will be parsed after the main file.
+ * For instance, if <envar>LANG</envar> is set to <literal>ja_JP.ujis</literal>,
+ * when loading the default file <filename>~/.gtkrc</filename> then GTK+ looks
+ * for <filename>~/.gtkrc.ja_JP</filename> and <filename>~/.gtkrc.ja</filename>,
+ * and parses the first of those that exists.</para>
+ * </para>
+ * </refsect2>
+ * <refsect2>
+ * <title>Pathnames and patterns</title>
+ * <anchor id="gtkrc-pathnames-and-patterns"/>
+ * <para>
+ * A resource file defines a number of styles and key bindings and
+ * attaches them to particular widgets. The attachment is done
+ * by the <literal>widget</literal>, <literal>widget_class</literal>,
+ * and <literal>class</literal> declarations. As an example
+ * of such a statement:
+ *
+ * <informalexample><programlisting>
+ * widget "mywindow.*.GtkEntry" style "my-entry-class"
+ * </programlisting></informalexample>
+ *
+ * attaches the style <literal>"my-entry-class"</literal> to all
+ * widgets whose <firstterm>widget path</firstterm> matches the
+ * <firstterm>pattern</firstterm> <literal>"mywindow.*.GtkEntry"</literal>.
+ * That is, all #GtkEntry widgets which are part of a #GtkWindow named
+ * <literal>"mywindow"</literal>.
+ *
+ * The patterns here are given in the standard shell glob syntax.
+ * The <literal>"?"</literal> wildcard matches any character, while
+ * <literal>"*"</literal> matches zero or more of any character.
+ * The three types of matching are against the widget path, the
+ * <firstterm>class path</firstterm> and the class hierarchy. Both the
+ * widget path and the class path consist of a <literal>"."</literal>
+ * separated list of all the parents of the widget and the widget itself
+ * from outermost to innermost. The difference is that in the widget path,
+ * the name assigned by gtk_widget_set_name() is used if present, otherwise
+ * the class name of the widget, while for the class path, the class name is
+ * always used.
+ *
+ * Since GTK+ 2.10, <literal>widget_class</literal> paths can also contain
+ * <literal><classname></literal> substrings, which are matching
+ * the class with the given name and any derived classes. For instance,
+ * <informalexample><programlisting>
+ * widget_class "*<GtkMenuItem>.GtkLabel" style "my-style"
+ * </programlisting></informalexample>
+ * will match #GtkLabel widgets which are contained in any kind of menu item.
+ *
+ * So, if you have a #GtkEntry named <literal>"myentry"</literal>, inside of a
+ * horizontal box in a window named <literal>"mywindow"</literal>, then the
+ * widget path is: <literal>"mywindow.GtkHBox.myentry"</literal>
+ * while the class path is: <literal>"GtkWindow.GtkHBox.GtkEntry"</literal>.
+ *
+ * Matching against class is a little different. The pattern match is done
+ * against all class names in the widgets class hierarchy (not the layout
+ * hierarchy) in sequence, so the pattern:
+ * <informalexample><programlisting>
+ * class "GtkButton" style "my-style"
+ * </programlisting></informalexample>
+ * will match not just #GtkButton widgets, but also #GtkToggleButton and
+ * #GtkCheckButton widgets, since those classes derive from #GtkButton.
+ *
+ * Additionally, a priority can be specified for each pattern, and styles
+ * override other styles first by priority, then by pattern type and then
+ * by order of specification (later overrides earlier). The priorities
+ * that can be specified are (highest to lowest):
+ * <simplelist>
+ * <member><literal>highest</literal></member>
+ * <member><literal>rc</literal></member>
+ * <member><literal>theme</literal></member>
+ * <member><literal>application</literal></member>
+ * <member><literal>gtk</literal></member>
+ * <member><literal>lowest</literal></member>
+ * </simplelist>
+ * <literal>rc</literal> is the default for styles
+ * read from an RC file, <literal>theme</literal>
+ * is the default for styles read from theme RC files,
+ * <literal>application</literal>
+ * should be used for styles an application sets
+ * up, and <literal>gtk</literal> is used for styles
+ * that GTK+ creates internally.
+ * </para>
+ * </refsect2>
+ * <refsect2>
+ * <title>Theme gtkrc files</title>
+ * <anchor id="theme-gtkrc-files"/>
+ * <para>
+ * Theme RC files are loaded first from under the <filename>~/.themes/</filename>,
+ * then from the directory from gtk_rc_get_theme_dir(). The files looked at will
+ * be <filename>gtk-3.0/gtkrc</filename>.
+ *
+ * When the application prefers dark themes
+ * (see the #GtkSettings:gtk-application-prefer-dark-theme property for details),
+ * <filename>gtk-3.0/gtkrc-dark</filename> will be loaded first, and if not present
+ * <filename>gtk-3.0/gtkrc</filename> will be loaded.
+ * </para>
+ * </refsect2>
+ * <refsect2>
+ * <title>Optimizing RC Style Matches</title>
+ * <anchor id="optimizing-rc-style-matches"/>
+ * <para>
+ * Everytime a widget is created and added to the layout hierarchy of a #GtkWindow
+ * ("anchored" to be exact), a list of matching RC styles out of all RC styles read
+ * in so far is composed.
+ * For this, every RC style is matched against the widgets class path,
+ * the widgets name path and widgets inheritance hierarchy.
+ * As a consequence, significant slowdown can be caused by utilization of many
+ * RC styles and by using RC style patterns that are slow or complicated to match
+ * against a given widget.
+ * The following ordered list provides a number of advices (prioritized by
+ * effectiveness) to reduce the performance overhead associated with RC style
+ * matches:
+ *
+ * <orderedlist>
+ * <listitem><para>
+ * Move RC styles for specific applications into RC files dedicated to those
+ * applications and parse application specific RC files only from
+ * applications that are affected by them.
+ * This reduces the overall amount of RC styles that have to be considered
+ * for a match across a group of applications.
+ * </para></listitem>
+ * <listitem><para>
+ * Merge multiple styles which use the same matching rule, for instance:
+ * <informalexample><programlisting>
+ * style "Foo" { foo_content }
+ * class "X" style "Foo"
+ * style "Bar" { bar_content }
+ * class "X" style "Bar"
+ * </programlisting></informalexample>
+ * is faster to match as:
+ * <informalexample><programlisting>
+ * style "FooBar" { foo_content bar_content }
+ * class "X" style "FooBar"
+ * </programlisting></informalexample>
+ * </para></listitem>
+ * <listitem><para>
+ * Use of wildcards should be avoided, this can reduce the individual RC style
+ * match to a single integer comparison in most cases.
+ * </para></listitem>
+ * <listitem><para>
+ * To avoid complex recursive matching, specification of full class names
+ * (for <literal>class</literal> matches) or full path names (for
+ * <literal>widget</literal> and <literal>widget_class</literal> matches)
+ * is to be preferred over shortened names
+ * containing <literal>"*"</literal> or <literal>"?"</literal>.
+ * </para></listitem>
+ * <listitem><para>
+ * If at all necessary, wildcards should only be used at the tail or head
+ * of a pattern. This reduces the match complexity to a string comparison
+ * per RC style.
+ * </para></listitem>
+ * <listitem><para>
+ * When using wildcards, use of <literal>"?"</literal> should be preferred
+ * over <literal>"*"</literal>. This can reduce the matching complexity from
+ * O(n^2) to O(n). For example <literal>"Gtk*Box"</literal> can be turned into
+ * <literal>"Gtk?Box"</literal> and will still match #GtkHBox and #GtkVBox.
+ * </para></listitem>
+ * <listitem><para>
+ * The use of <literal>"*"</literal> wildcards should be restricted as much
+ * as possible, because matching <literal>"A*B*C*RestString"</literal> can
+ * result in matching complexities of O(n^2) worst case.
+ * </para></listitem>
+ * </orderedlist>
+ * </para>
+ * </refsect2>
+ * <refsect2>
+ * <title>Toplevel declarations</title>
+ * <para>
+ * An RC file is a text file which is composed of a sequence
+ * of declarations. <literal>'#'</literal> characters delimit comments and
+ * the portion of a line after a <literal>'#'</literal> is ignored when parsing
+ * an RC file.
+ *
+ * The possible toplevel declarations are:
+ *
+ * <variablelist>
+ * <varlistentry>
+ * <term><literal>binding <replaceable>name</replaceable>
+ * { ... }</literal></term>
+ * <listitem>
+ * <para>Declares a binding set.</para>
+ * </listitem>
+ * </varlistentry>
+ * <varlistentry>
+ * <term><literal>class <replaceable>pattern</replaceable>
+ * [ style | binding ][ : <replaceable>priority</replaceable> ]
+ * <replaceable>name</replaceable></literal></term>
+ * <listitem>
+ * <para>Specifies a style or binding set for a particular
+ * branch of the inheritance hierarchy.</para>
+ * </listitem>
+ * </varlistentry>
+ * <varlistentry>
+ * <term><literal>include <replaceable>filename</replaceable></literal></term>
+ * <listitem>
+ * <para>Parses another file at this point. If
+ * <replaceable>filename</replaceable> is not an absolute filename,
+ * it is searched in the directories of the currently open RC files.</para>
+ * <para>GTK+ also tries to load a
+ * <link linkend="locale-specific-rc">locale-specific variant</link> of
+ * the included file.</para>
+ * </listitem>
+ * </varlistentry>
+ * <varlistentry>
+ * <term><literal>module_path <replaceable>path</replaceable></literal></term>
+ * <listitem>
+ * <para>Sets a path (a list of directories separated
+ * by colons) that will be searched for theme engines referenced in
+ * RC files.</para>
+ * </listitem>
+ * </varlistentry>
+ * <varlistentry>
+ * <term><literal>pixmap_path <replaceable>path</replaceable></literal></term>
+ * <listitem>
+ * <para>Sets a path (a list of directories separated
+ * by colons) that will be searched for pixmaps referenced in
+ * RC files.</para>
+ * </listitem>
+ * </varlistentry>
+ * <varlistentry>
+ * <term><literal>im_module_file <replaceable>pathname</replaceable></literal></term>
+ * <listitem>
+ * <para>Sets the pathname for the IM modules file. Setting this from RC files
+ * is deprecated; you should use the environment variable <envar>GTK_IM_MODULE_FILE</envar>
+ * instead.</para>
+ * </listitem>
+ * </varlistentry>
+ * <varlistentry>
+ * <term><literal>style <replaceable>name</replaceable> [ =
+ * <replaceable>parent</replaceable> ] { ... }</literal></term>
+ * <listitem>
+ * <para>Declares a style.</para>
+ * </listitem>
+ * </varlistentry>
+ * <varlistentry>
+ * <term><literal>widget <replaceable>pattern</replaceable>
+ * [ style | binding ][ : <replaceable>priority</replaceable> ]
+ * <replaceable>name</replaceable></literal></term>
+ * <listitem>
+ * <para>Specifies a style or binding set for a particular
+ * group of widgets by matching on the widget pathname.</para>
+ * </listitem>
+ * </varlistentry>
+ * <varlistentry>
+ * <term><literal>widget_class <replaceable>pattern</replaceable>
+ * [ style | binding ][ : <replaceable>priority</replaceable> ]
+ * <replaceable>name</replaceable></literal></term>
+ * <listitem>
+ * <para>Specifies a style or binding set for a particular
+ * group of widgets by matching on the class pathname.</para>
+ * </listitem>
+ * </varlistentry>
+ * <varlistentry>
+ * <term><replaceable>setting</replaceable> = <replaceable>value</replaceable></term>
+ * <listitem>
+ * <para>Specifies a value for a <link linkend="GtkSettings">setting</link>.
+ * Note that settings in RC files are overwritten by system-wide settings
+ * (which are managed by an XSettings manager on X11).</para>
+ * </listitem>
+ * </varlistentry>
+ * </variablelist>
+ * </para>
+ * </refsect2>
+ * <refsect2>
+ * <title>Styles</title>
+ * <para>
+ * A RC style is specified by a <literal>style</literal>
+ * declaration in a RC file, and then bound to widgets
+ * with a <literal>widget</literal>, <literal>widget_class</literal>,
+ * or <literal>class</literal> declaration. All styles
+ * applying to a particular widget are composited together
+ * with <literal>widget</literal> declarations overriding
+ * <literal>widget_class</literal> declarations which, in
+ * turn, override <literal>class</literal> declarations.
+ * Within each type of declaration, later declarations override
+ * earlier ones.
+ *
+ * Within a <literal>style</literal> declaration, the possible
+ * elements are:
+ *
+ * <variablelist>
+ * <varlistentry>
+ * <term><literal>bg[<replaceable>state</replaceable>] =
+ * <replaceable>color</replaceable></literal></term>
+ * <listitem>
+ * Sets the color used for the background of most widgets.
+ * </listitem>
+ * </varlistentry>
+ * <varlistentry>
+ * <term><literal>fg[<replaceable>state</replaceable>] =
+ * <replaceable>color</replaceable></literal></term>
+ * <listitem>
+ * Sets the color used for the foreground of most widgets.
+ * </listitem>
+ * </varlistentry>
+ * <varlistentry>
+ * <term><literal>base[<replaceable>state</replaceable>] =
+ * <replaceable>color</replaceable></literal></term>
+ * <listitem>
+ * Sets the color used for the background of widgets displaying
+ * editable text. This color is used for the background
+ * of, among others, #GtkText, #GtkEntry, #GtkList, and #GtkCList.
+ * </listitem>
+ * </varlistentry>
+ * <varlistentry>
+ * <term><literal>text[<replaceable>state</replaceable>] =
+ * <replaceable>color</replaceable></literal></term>
+ * <listitem>
+ * Sets the color used for foreground of widgets using
+ * <literal>base</literal> for the background color.
+ * </listitem>
+ * </varlistentry>
+ * <varlistentry>
+ * <term><literal>xthickness =
+ * <replaceable>number</replaceable></literal></term>
+ * <listitem>
+ * Sets the xthickness, which is used for various horizontal padding
+ * values in GTK+.
+ * </listitem>
+ * </varlistentry>
+ * <varlistentry>
+ * <term><literal>ythickness =
+ * <replaceable>number</replaceable></literal></term>
+ * <listitem>
+ * Sets the ythickness, which is used for various vertical padding
+ * values in GTK+.
+ * </listitem>
+ * </varlistentry>
+ * <varlistentry>
+ * <term><literal>bg_pixmap[<replaceable>state</replaceable>] =
+ * <replaceable>pixmap</replaceable></literal></term>
+ * <listitem>
+ * Sets a background pixmap to be used in place of
+ * the <literal>bg</literal> color (or for #GtkText,
+ * in place of the <literal>base</literal> color. The special
+ * value <literal>"<parent>"</literal> may be used to indicate that the widget should
+ * use the same background pixmap as its parent. The special value
+ * <literal>"<none>"</literal> may be used to indicate no background pixmap.
+ * </listitem>
+ * </varlistentry>
+ * <varlistentry>
+ * <term><literal>font = <replaceable>font</replaceable></literal></term>
+ * <listitem>
+ * Starting with GTK+ 2.0, the "font" and "fontset"
+ * declarations are ignored; use "font_name" declarations instead.
+ * </listitem>
+ * </varlistentry>
+ * <varlistentry>
+ * <term><literal>fontset = <replaceable>font</replaceable></literal></term>
+ * <listitem>
+ * Starting with GTK+ 2.0, the "font" and "fontset"
+ * declarations are ignored; use "font_name" declarations instead.
+ * </listitem>
+ * </varlistentry>
+ * <varlistentry>
+ * <term><literal>font_name = <replaceable>font</replaceable></literal></term>
+ * <listitem>
+ * Sets the font for a widget. <replaceable>font</replaceable> must be
+ * a Pango font name, e.g. <literal>"Sans Italic 10"</literal>.
+ * For details about Pango font names, see
+ * pango_font_description_from_string().
+ * </listitem>
+ * </varlistentry>
+ * <varlistentry>
+ * <term><literal>stock[<replaceable>"stock-id"</replaceable>] = { <replaceable>icon source specifications</replaceable> }</literal></term>
+ * <listitem>
+ * Defines the icon for a stock item.
+ * </listitem>
+ * </varlistentry>
+ * <varlistentry>
+ * <term><literal>color[<replaceable>"color-name"</replaceable>] = <replaceable>color specification</replaceable></literal></term>
+ * <listitem>
+ * Since 2.10, this element can be used to defines symbolic colors. See below for
+ * the syntax of color specifications.
+ * </listitem>
+ * </varlistentry>
+ * <varlistentry>
+ * <term><literal>engine <replaceable>"engine"</replaceable> { <replaceable>engine-specific
+ * settings</replaceable> }</literal></term>
+ * <listitem>
+ * Defines the engine to be used when drawing with this style.
+ * </listitem>
+ * </varlistentry>
+ * <varlistentry>
+ * <term><literal><replaceable>class</replaceable>::<replaceable>property</replaceable> = <replaceable>value</replaceable></literal></term>
+ * <listitem>
+ * Sets a <link linkend="style-properties">style property</link> for a widget class.
+ * </listitem>
+ * </varlistentry>
+ * </variablelist>
+ *
+ * The colors and background pixmaps are specified as a function of the
+ * state of the widget. The states are:
+ *
+ * <variablelist>
+ * <varlistentry>
+ * <term><literal>NORMAL</literal></term>
+ * <listitem>
+ * A color used for a widget in its normal state.
+ * </listitem>
+ * </varlistentry>
+ * <varlistentry>
+ * <term><literal>ACTIVE</literal></term>
+ * <listitem>
+ * A variant of the <literal>NORMAL</literal> color used when the
+ * widget is in the %GTK_STATE_ACTIVE state, and also for
+ * the trough of a ScrollBar, tabs of a NoteBook
+ * other than the current tab and similar areas.
+ * Frequently, this should be a darker variant
+ * of the <literal>NORMAL</literal> color.
+ * </listitem>
+ * </varlistentry>
+ * <varlistentry>
+ * <term><literal>PRELIGHT</literal></term>
+ * <listitem>
+ * A color used for widgets in the %GTK_STATE_PRELIGHT state. This
+ * state is the used for Buttons and MenuItems
+ * that have the mouse cursor over them, and for
+ * their children.
+ * </listitem>
+ * </varlistentry>
+ * <varlistentry>
+ * <term><literal>SELECTED</literal></term>
+ * <listitem>
+ * A color used to highlight data selected by the user.
+ * for instance, the selected items in a list widget, and the
+ * selection in an editable widget.
+ * </listitem>
+ * </varlistentry>
+ * <varlistentry>
+ * <term><literal>INSENSITIVE</literal></term>
+ * <listitem>
+ * A color used for the background of widgets that have
+ * been set insensitive with gtk_widget_set_sensitive().
+ * </listitem>
+ * </varlistentry>
+ * </variablelist>
+ *
+ * <anchor id="color-format"/>
+ * Colors can be specified as a string containing a color name (GTK+ knows
+ * all names from the X color database <filename>/usr/lib/X11/rgb.txt</filename>),
+ * in one of the hexadecimal forms <literal>#rrrrggggbbbb</literal>,
+ * <literal>#rrrgggbbb</literal>, <literal>#rrggbb</literal>,
+ * or <literal>#rgb</literal>, where <literal>r</literal>,
+ * <literal>g</literal> and <literal>b</literal> are
+ * hex digits, or they can be specified as a triplet
+ * <literal>{ <replaceable>r</replaceable>, <replaceable>g</replaceable>,
+ * <replaceable>b</replaceable>}</literal>, where <literal>r</literal>,
+ * <literal>g</literal> and <literal>b</literal> are either integers in
+ * the range 0-65535 or floats in the range 0.0-1.0.
+ *
+ * Since 2.10, colors can also be specified by refering to a symbolic color, as
+ * follows: <literal>@<!-- -->color-name</literal>, or by using expressions to combine
+ * colors. The following expressions are currently supported:
+ * <variablelist>
+ * <varlistentry>
+ * <term>mix (<replaceable>factor</replaceable>, <replaceable>color1</replaceable>, <replaceable>color2</replaceable>)</term>
+ * <listitem><para>
+ * Computes a new color by mixing <replaceable>color1</replaceable> and
+ * <replaceable>color2</replaceable>. The <replaceable>factor</replaceable>
+ * determines how close the new color is to <replaceable>color1</replaceable>.
+ * A factor of 1.0 gives pure <replaceable>color1</replaceable>, a factor of
+ * 0.0 gives pure <replaceable>color2</replaceable>.
+ * </para></listitem>
+ * </varlistentry>
+ * <varlistentry>
+ * <term>shade (<replaceable>factor</replaceable>, <replaceable>color</replaceable>)</term>
+ * <listitem><para>
+ * Computes a lighter or darker variant of <replaceable>color</replaceable>.
+ * A <replaceable>factor</replaceable> of 1.0 leaves the color unchanged, smaller
+ * factors yield darker colors, larger factors yield lighter colors.
+ * </para></listitem>
+ * </varlistentry>
+ * <varlistentry>
+ * <term>lighter (<replaceable>color</replaceable>)</term>
+ * <listitem><para>
+ * This is an abbreviation for
+ * <literal>shade (1.3, <replaceable>color</replaceable>)</literal>.
+ * </para></listitem>
+ * </varlistentry>
+ * <varlistentry>
+ * <term>darker (<replaceable>color</replaceable>)</term>
+ * <listitem><para>
+ * This is an abbreviation for
+ * <literal>shade (0.7, <replaceable>color</replaceable>)</literal>.
+ * </para></listitem>
+ * </varlistentry>
+ * </variablelist>
+ *
+ * Here are some examples of color expressions:
+ *
+ * <informalexample><programlisting>
+ * mix (0.5, "red", "blue")
+ * shade (1.5, mix (0.3, "#0abbc0", { 0.3, 0.5, 0.9 }))
+ * lighter (@<!-- -->foreground)
+ * </programlisting></informalexample>
+ *
+ * In a <literal>stock</literal> definition, icon sources are specified as a
+ * 4-tuple of image filename or icon name, text direction, widget state, and size, in that
+ * order. Each icon source specifies an image filename or icon name to use with a given
+ * direction, state, and size. Filenames are specified as a string such
+ * as <literal>"itemltr.png"</literal>, while icon names (looked up
+ * in the current icon theme), are specified with a leading
+ * <literal>@</literal>, such as <literal>@"item-ltr"</literal>.
+ * The <literal>*</literal> character can be used as a
+ * wildcard, and if direction/state/size are omitted they default to
+ * <literal>*</literal>. So for example, the following specifies different icons to
+ * use for left-to-right and right-to-left languages:
+ *
+ * <informalexample><programlisting>
+ * stock["my-stock-item"] =
+ * {
+ * { "itemltr.png", LTR, *, * },
+ * { "itemrtl.png", RTL, *, * }
+ * }
+ * </programlisting></informalexample>
+ *
+ * This could be abbreviated as follows:
+ *
+ * <informalexample><programlisting>
+ * stock["my-stock-item"] =
+ * {
+ * { "itemltr.png", LTR },
+ * { "itemrtl.png", RTL }
+ * }
+ * </programlisting></informalexample>
+ *
+ * You can specify custom icons for specific sizes, as follows:
+ *
+ * <informalexample><programlisting>
+ * stock["my-stock-item"] =
+ * {
+ * { "itemmenusize.png", *, *, "gtk-menu" },
+ * { "itemtoolbarsize.png", *, *, "gtk-large-toolbar" }
+ * { "itemgeneric.png" } // implicit *, *, * as a fallback
+ * }
+ * </programlisting></informalexample>
+ *
+ * The sizes that come with GTK+ itself are <literal>"gtk-menu"</literal>,
+ * <literal>"gtk-small-toolbar"</literal>, <literal>"gtk-large-toolbar"</literal>,
+ * <literal>"gtk-button"</literal>, <literal>"gtk-dialog"</literal>. Applications
+ * can define other sizes.
+ *
+ * It's also possible to use custom icons for a given state, for example:
+ *
+ * <informalexample><programlisting>
+ * stock["my-stock-item"] =
+ * {
+ * { "itemprelight.png", *, PRELIGHT },
+ * { "iteminsensitive.png", *, INSENSITIVE },
+ * { "itemgeneric.png" } // implicit *, *, * as a fallback
+ * }
+ * </programlisting></informalexample>
+ *
+ * When selecting an icon source to use, GTK+ will consider text direction most
+ * important, state second, and size third. It will select the best match based on
+ * those criteria. If an attribute matches exactly (e.g. you specified
+ * <literal>PRELIGHT</literal> or specified the size), GTK+ won't modify the image;
+ * if the attribute matches with a wildcard, GTK+ will scale or modify the image to
+ * match the state and size the user requested.
+ * </para>
+ * </refsect2>
+ * <refsect2>
+ * <title>Key bindings</title>
+ * <para>
+ * Key bindings allow the user to specify actions to be
+ * taken on particular key presses. The form of a binding
+ * set declaration is:
+ *
+ * <informalexample><programlisting>
+ * binding <replaceable>name</replaceable> {
+ * bind <replaceable>key</replaceable> {
+ * <replaceable>signalname</replaceable> (<replaceable>param</replaceable>, ...)
+ * ...
+ * }
+ * ...
+ * }
+ * </programlisting></informalexample>
+ *
+ * <replaceable>key</replaceable> is a string consisting of a
+ * series of modifiers followed by the name of a key. The
+ * modifiers can be:
+ * <simplelist>
+ * <member><literal><alt></literal></member>
+ * <member><literal><ctl></literal></member>
+ * <member><literal><control></literal></member>
+ * <member><literal><meta></literal></member>
+ * <member><literal><hyper></literal></member>
+ * <member><literal><super></literal></member>
+ * <member><literal><mod1></literal></member>
+ * <member><literal><mod2></literal></member>
+ * <member><literal><mod3></literal></member>
+ * <member><literal><mod4></literal></member>
+ * <member><literal><mod5></literal></member>
+ * <member><literal><release></literal></member>
+ * <member><literal><shft></literal></member>
+ * <member><literal><shift></literal></member>
+ * </simplelist>
+ * <literal><shft></literal> is an alias for
+ * <literal><shift></literal>,
+ * <literal><ctl></literal> is an alias for
+ * <literal><control></literal>,
+ * and
+ * <literal><alt></literal> is an alias for
+ * <literal><mod1></literal>.
+ *
+ * The action that is bound to the key is a sequence
+ * of signal names (strings) followed by parameters for
+ * each signal. The signals must be action signals.
+ * (See g_signal_new()). Each parameter can be
+ * a float, integer, string, or unquoted string
+ * representing an enumeration value. The types of
+ * the parameters specified must match the types of the
+ * parameters of the signal.
+ *
+ * Binding sets are connected to widgets in the same manner as styles,
+ * with one difference: Binding sets override other binding sets first
+ * by pattern type, then by priority and then by order of specification.
+ * The priorities that can be specified and their default values are the
+ * same as for styles.
+ * </para>
+ * </refsect2>
+ */
+
+
+enum
+{
+ PATH_ELT_PSPEC,
+ PATH_ELT_UNRESOLVED,
+ PATH_ELT_TYPE
+};
+
+typedef struct
+{
+ gint type;
+ union
+ {
+ GType class_type;
+ gchar *class_name;
+ GPatternSpec *pspec;
+ } elt;
+} PathElt;
+
+#define GTK_RC_STYLE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_RC_STYLE, GtkRcStylePrivate))
+
+typedef struct _GtkRcStylePrivate GtkRcStylePrivate;
+
+struct _GtkRcStylePrivate
+{
+ GSList *color_hashes;
+};
+
+static void gtk_rc_style_finalize (GObject *object);
+static void gtk_rc_style_real_merge (GtkRcStyle *dest,
+ GtkRcStyle *src);
+static GtkRcStyle* gtk_rc_style_real_create_rc_style (GtkRcStyle *rc_style);
+static GtkStyle* gtk_rc_style_real_create_style (GtkRcStyle *rc_style);
+static gint gtk_rc_properties_cmp (gconstpointer bsearch_node1,
+ gconstpointer bsearch_node2);
+
+static void insert_rc_property (GtkRcStyle *style,
+ GtkRcProperty *property,
+ gboolean replace);
+
+
+static const GScannerConfig gtk_rc_scanner_config =
+{
+ (
+ " \t\r\n"
+ ) /* cset_skip_characters */,
+ (
+ "_"
+ G_CSET_a_2_z
+ G_CSET_A_2_Z
+ ) /* cset_identifier_first */,
+ (
+ G_CSET_DIGITS
+ "-_"
+ G_CSET_a_2_z
+ G_CSET_A_2_Z
+ ) /* cset_identifier_nth */,
+ ( "#\n" ) /* cpair_comment_single */,
+
+ TRUE /* case_sensitive */,
+
+ TRUE /* skip_comment_multi */,
+ TRUE /* skip_comment_single */,
+ TRUE /* scan_comment_multi */,
+ TRUE /* scan_identifier */,
+ FALSE /* scan_identifier_1char */,
+ FALSE /* scan_identifier_NULL */,
+ TRUE /* scan_symbols */,
+ TRUE /* scan_binary */,
+ TRUE /* scan_octal */,
+ TRUE /* scan_float */,
+ TRUE /* scan_hex */,
+ TRUE /* scan_hex_dollar */,
+ TRUE /* scan_string_sq */,
+ TRUE /* scan_string_dq */,
+ TRUE /* numbers_2_int */,
+ FALSE /* int_2_float */,
+ FALSE /* identifier_2_string */,
+ TRUE /* char_2_token */,
+ TRUE /* symbol_2_token */,
+ FALSE /* scope_0_fallback */,
+};
+
+static const gchar symbol_names[] =
+ "include\0"
+ "NORMAL\0"
+ "ACTIVE\0"
+ "PRELIGHT\0"
+ "SELECTED\0"
+ "INSENSITIVE\0"
+ "fg\0"
+ "bg\0"
+ "text\0"
+ "base\0"
+ "xthickness\0"
+ "ythickness\0"
+ "font\0"
+ "fontset\0"
+ "font_name\0"
+ "bg_pixmap\0"
+ "pixmap_path\0"
+ "style\0"
+ "binding\0"
+ "bind\0"
+ "widget\0"
+ "widget_class\0"
+ "class\0"
+ "lowest\0"
+ "gtk\0"
+ "application\0"
+ "theme\0"
+ "rc\0"
+ "highest\0"
+ "engine\0"
+ "module_path\0"
+ "stock\0"
+ "im_module_file\0"
+ "LTR\0"
+ "RTL\0"
+ "color\0"
+ "unbind\0";
+
+static const struct
+{
+ guint name_offset;
+ guint token;
+} symbols[] = {
+ { 0, GTK_RC_TOKEN_INCLUDE },
+ { 8, GTK_RC_TOKEN_NORMAL },
+ { 15, GTK_RC_TOKEN_ACTIVE },
+ { 22, GTK_RC_TOKEN_PRELIGHT },
+ { 31, GTK_RC_TOKEN_SELECTED },
+ { 40, GTK_RC_TOKEN_INSENSITIVE },
+ { 52, GTK_RC_TOKEN_FG },
+ { 55, GTK_RC_TOKEN_BG },
+ { 58, GTK_RC_TOKEN_TEXT },
+ { 63, GTK_RC_TOKEN_BASE },
+ { 68, GTK_RC_TOKEN_XTHICKNESS },
+ { 79, GTK_RC_TOKEN_YTHICKNESS },
+ { 90, GTK_RC_TOKEN_FONT },
+ { 95, GTK_RC_TOKEN_FONTSET },
+ { 103, GTK_RC_TOKEN_FONT_NAME },
+ { 113, GTK_RC_TOKEN_BG_PIXMAP },
+ { 123, GTK_RC_TOKEN_PIXMAP_PATH },
+ { 135, GTK_RC_TOKEN_STYLE },
+ { 141, GTK_RC_TOKEN_BINDING },
+ { 149, GTK_RC_TOKEN_BIND },
+ { 154, GTK_RC_TOKEN_WIDGET },
+ { 161, GTK_RC_TOKEN_WIDGET_CLASS },
+ { 174, GTK_RC_TOKEN_CLASS },
+ { 180, GTK_RC_TOKEN_LOWEST },
+ { 187, GTK_RC_TOKEN_GTK },
+ { 191, GTK_RC_TOKEN_APPLICATION },
+ { 203, GTK_RC_TOKEN_THEME },
+ { 209, GTK_RC_TOKEN_RC },
+ { 212, GTK_RC_TOKEN_HIGHEST },
+ { 220, GTK_RC_TOKEN_ENGINE },
+ { 227, GTK_RC_TOKEN_MODULE_PATH },
+ { 239, GTK_RC_TOKEN_STOCK },
+ { 245, GTK_RC_TOKEN_IM_MODULE_FILE },
+ { 260, GTK_RC_TOKEN_LTR },
+ { 264, GTK_RC_TOKEN_RTL },
+ { 268, GTK_RC_TOKEN_COLOR },
+ { 274, GTK_RC_TOKEN_UNBIND }
+};
+
+static GHashTable *realized_style_ht = NULL;
+
+static gchar *im_module_file = NULL;
+
+static gchar **gtk_rc_default_files = NULL;
+
+/* RC file handling */
+
+static gchar *
+gtk_rc_make_default_dir (const gchar *type)
+{
+ const gchar *var;
+ gchar *path;
+
+ var = g_getenv ("GTK_EXE_PREFIX");
+
+ if (var)
+ path = g_build_filename (var, "lib", "gtk-3.0", GTK_BINARY_VERSION, type, NULL);
+ else
+ path = g_build_filename (_gtk_get_libdir (), "gtk-3.0", GTK_BINARY_VERSION, type, NULL);
+
+ return path;
+}
+
+/**
+ * gtk_rc_get_im_module_path:
+ *
+ * Obtains the path in which to look for IM modules. See the documentation
+ * of the <link linkend="im-module-path"><envar>GTK_PATH</envar></link>
+ * environment variable for more details about looking up modules. This
+ * function is useful solely for utilities supplied with GTK+ and should
+ * not be used by applications under normal circumstances.
+ *
+ * Returns: (type filename): a newly-allocated string containing the
+ * path in which to look for IM modules.
+ *
+ * Deprecated: 3.0: Use #GtkCssProvider instead.
+ */
+gchar *
+gtk_rc_get_im_module_path (void)
+{
+ gchar **paths = _gtk_get_module_path ("immodules");
+ gchar *result = g_strjoinv (G_SEARCHPATH_SEPARATOR_S, paths);
+ g_strfreev (paths);
+
+ return result;
+}
+
+/**
+ * gtk_rc_get_im_module_file:
+ *
+ * Obtains the path to the IM modules file. See the documentation
+ * of the <link linkend="im-module-file"><envar>GTK_IM_MODULE_FILE</envar></link>
+ * environment variable for more details.
+ *
+ * Returns: (type filename): a newly-allocated string containing the
+ * name of the file listing the IM modules available for loading
+ *
+ * Deprecated: 3.0: Use #GtkCssProvider instead.
+ */
+gchar *
+gtk_rc_get_im_module_file (void)
+{
+ const gchar *var = g_getenv ("GTK_IM_MODULE_FILE");
+ gchar *result = NULL;
+
+ if (var)
+ result = g_strdup (var);
+
+ if (!result)
+ {
+ if (im_module_file)
+ result = g_strdup (im_module_file);
+ else
+ result = gtk_rc_make_default_dir ("immodules.cache");
+ }
+
+ return result;
+}
+
+/**
+ * gtk_rc_get_theme_dir:
+ *
+ * Returns the standard directory in which themes should
+ * be installed. (GTK+ does not actually use this directory
+ * itself.)
+ *
+ * Returns: The directory (must be freed with g_free()).
+ *
+ * Deprecated: 3.0: Use #GtkCssProvider instead.
+ */
+gchar *
+gtk_rc_get_theme_dir (void)
+{
+ const gchar *var;
+ gchar *path;
+
+ var = g_getenv ("GTK_DATA_PREFIX");
+
+ if (var)
+ path = g_build_filename (var, "share", "themes", NULL);
+ else
+ path = g_build_filename (_gtk_get_data_prefix (), "share", "themes", NULL);
+
+ return path;
+}
+
+/**
+ * gtk_rc_get_module_dir:
+ *
+ * Returns a directory in which GTK+ looks for theme engines.
+ * For full information about the search for theme engines,
+ * see the docs for <envar>GTK_PATH</envar> in
+ * <xref linkend="gtk-running"/>.
+ *
+ * return value: (type filename): the directory. (Must be freed with g_free())
+ *
+ * Deprecated: 3.0: Use #GtkCssProvider instead.
+ **/
+gchar *
+gtk_rc_get_module_dir (void)
+{
+ return gtk_rc_make_default_dir ("engines");
+}
+
+/**
+ * gtk_rc_add_default_file:
+ * @filename: (type filename): the pathname to the file. If @filename
+ * is not absolute, it is searched in the current directory.
+ *
+ * Adds a file to the list of files to be parsed at the
+ * end of gtk_init().
+ *
+ * Deprecated:3.0: Use #GtkStyleContext with a custom #GtkStyleProvider instead
+ **/
+void
+gtk_rc_add_default_file (const gchar *filename)
+{
+}
+
+/**
+ * gtk_rc_set_default_files:
+ * @filenames: (array zero-terminated=1) (element-type filename): A
+ * %NULL-terminated list of filenames.
+ *
+ * Sets the list of files that GTK+ will read at the
+ * end of gtk_init().
+ *
+ * Deprecated:3.0: Use #GtkStyleContext with a custom #GtkStyleProvider instead
+ **/
+void
+gtk_rc_set_default_files (gchar **filenames)
+{
+}
+
+/**
+ * gtk_rc_get_default_files:
+ *
+ * Retrieves the current list of RC files that will be parsed
+ * at the end of gtk_init().
+ *
+ * Return value: (transfer none) (array zero-terminated=1) (element-type filename):
+ * A %NULL-terminated array of filenames. This memory is owned
+ * by GTK+ and must not be freed by the application. If you want
+ * to store this information, you should make a copy.
+ *
+ * Deprecated:3.0: Use #GtkStyleContext instead
+ **/
+gchar **
+gtk_rc_get_default_files (void)
+{
+ return gtk_rc_default_files;
+}
+
+/**
+ * gtk_rc_parse_string:
+ * @rc_string: a string to parse.
+ *
+ * Parses resource information directly from a string.
+ *
+ * Deprecated: 3.0: Use #GtkCssProvider instead.
+ */
+void
+gtk_rc_parse_string (const gchar *rc_string)
+{
+ g_return_if_fail (rc_string != NULL);
+}
+
+/**
+ * gtk_rc_parse:
+ * @filename: the filename of a file to parse. If @filename is not absolute, it
+ * is searched in the current directory.
+ *
+ * Parses a given resource file.
+ *
+ * Deprecated: 3.0: Use #GtkCssProvider instead.
+ */
+void
+gtk_rc_parse (const gchar *filename)
+{
+ g_return_if_fail (filename != NULL);
+}
+
+/* Handling of RC styles */
+
+G_DEFINE_TYPE (GtkRcStyle, gtk_rc_style, G_TYPE_OBJECT)
+
+static void
+gtk_rc_style_init (GtkRcStyle *style)
+{
+ GtkRcStylePrivate *priv = GTK_RC_STYLE_GET_PRIVATE (style);
+ guint i;
+
+ style->name = NULL;
+ style->font_desc = NULL;
+
+ for (i = 0; i < 5; i++)
+ {
+ static const GdkColor init_color = { 0, 0, 0, 0, };
+
+ style->bg_pixmap_name[i] = NULL;
+ style->color_flags[i] = 0;
+ style->fg[i] = init_color;
+ style->bg[i] = init_color;
+ style->text[i] = init_color;
+ style->base[i] = init_color;
+ }
+ style->xthickness = -1;
+ style->ythickness = -1;
+ style->rc_properties = NULL;
+
+ style->rc_style_lists = NULL;
+ style->icon_factories = NULL;
+
+ priv->color_hashes = NULL;
+}
+
+static void
+gtk_rc_style_class_init (GtkRcStyleClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+ object_class->finalize = gtk_rc_style_finalize;
+
+ klass->parse = NULL;
+ klass->create_rc_style = gtk_rc_style_real_create_rc_style;
+ klass->merge = gtk_rc_style_real_merge;
+ klass->create_style = gtk_rc_style_real_create_style;
+
+ g_type_class_add_private (object_class, sizeof (GtkRcStylePrivate));
+}
+
+static void
+gtk_rc_style_finalize (GObject *object)
+{
+ GSList *tmp_list1, *tmp_list2;
+ GtkRcStyle *rc_style;
+ GtkRcStylePrivate *rc_priv;
+ gint i;
+
+ rc_style = GTK_RC_STYLE (object);
+ rc_priv = GTK_RC_STYLE_GET_PRIVATE (rc_style);
+
+ g_free (rc_style->name);
+ if (rc_style->font_desc)
+ pango_font_description_free (rc_style->font_desc);
+
+ for (i = 0; i < 5; i++)
+ g_free (rc_style->bg_pixmap_name[i]);
+
+ /* Now remove all references to this rc_style from
+ * realized_style_ht
+ */
+ tmp_list1 = rc_style->rc_style_lists;
+ while (tmp_list1)
+ {
+ GSList *rc_styles = tmp_list1->data;
+ GtkStyle *style = g_hash_table_lookup (realized_style_ht, rc_styles);
+ g_object_unref (style);
+
+ /* Remove the list of styles from the other rc_styles
+ * in the list
+ */
+ tmp_list2 = rc_styles;
+ while (tmp_list2)
+ {
+ GtkRcStyle *other_style = tmp_list2->data;
+
+ if (other_style != rc_style)
+ other_style->rc_style_lists = g_slist_remove_all (other_style->rc_style_lists,
+ rc_styles);
+ tmp_list2 = tmp_list2->next;
+ }
+
+ /* And from the hash table itself
+ */
+ g_hash_table_remove (realized_style_ht, rc_styles);
+ g_slist_free (rc_styles);
+
+ tmp_list1 = tmp_list1->next;
+ }
+ g_slist_free (rc_style->rc_style_lists);
+
+ if (rc_style->rc_properties)
+ {
+ guint i;
+
+ for (i = 0; i < rc_style->rc_properties->len; i++)
+ {
+ GtkRcProperty *node = &g_array_index (rc_style->rc_properties, GtkRcProperty, i);
+
+ g_free (node->origin);
+ g_value_unset (&node->value);
+ }
+ g_array_free (rc_style->rc_properties, TRUE);
+ rc_style->rc_properties = NULL;
+ }
+
+ g_slist_foreach (rc_style->icon_factories, (GFunc) g_object_unref, NULL);
+ g_slist_free (rc_style->icon_factories);
+
+ g_slist_foreach (rc_priv->color_hashes, (GFunc) g_hash_table_unref, NULL);
+ g_slist_free (rc_priv->color_hashes);
+
+ G_OBJECT_CLASS (gtk_rc_style_parent_class)->finalize (object);
+}
+
+/**
+ * gtk_rc_style_new:
+ *
+ * Creates a new #GtkRcStyle with no fields set and
+ * a reference count of 1.
+ *
+ * Returns: the newly-created #GtkRcStyle
+ *
+ * Deprecated: 3.0: Use #GtkCssProvider instead.
+ */
+GtkRcStyle *
+gtk_rc_style_new (void)
+{
+ GtkRcStyle *style;
+
+ style = g_object_new (GTK_TYPE_RC_STYLE, NULL);
+
+ return style;
+}
+
+/**
+ * gtk_rc_style_copy:
+ * @orig: the style to copy
+ *
+ * Makes a copy of the specified #GtkRcStyle. This function
+ * will correctly copy an RC style that is a member of a class
+ * derived from #GtkRcStyle.
+ *
+ * Return value: (transfer full): the resulting #GtkRcStyle
+ *
+ * Deprecated: 3.0: Use #GtkCssProvider instead.
+ **/
+GtkRcStyle *
+gtk_rc_style_copy (GtkRcStyle *orig)
+{
+ GtkRcStyle *style;
+
+ g_return_val_if_fail (GTK_IS_RC_STYLE (orig), NULL);
+
+ style = GTK_RC_STYLE_GET_CLASS (orig)->create_rc_style (orig);
+ GTK_RC_STYLE_GET_CLASS (style)->merge (style, orig);
+
+ return style;
+}
+
+static GtkRcStyle *
+gtk_rc_style_real_create_rc_style (GtkRcStyle *style)
+{
+ return g_object_new (G_OBJECT_TYPE (style), NULL);
+}
+
+static gint
+gtk_rc_properties_cmp (gconstpointer bsearch_node1,
+ gconstpointer bsearch_node2)
+{
+ const GtkRcProperty *prop1 = bsearch_node1;
+ const GtkRcProperty *prop2 = bsearch_node2;
+
+ if (prop1->type_name == prop2->type_name)
+ return prop1->property_name < prop2->property_name ? -1 : prop1->property_name == prop2->property_name ? 0 : 1;
+ else
+ return prop1->type_name < prop2->type_name ? -1 : 1;
+}
+
+static void
+insert_rc_property (GtkRcStyle *style,
+ GtkRcProperty *property,
+ gboolean replace)
+{
+ guint i;
+ GtkRcProperty *new_property = NULL;
+ GtkRcProperty key = { 0, 0, NULL, { 0, }, };
+
+ key.type_name = property->type_name;
+ key.property_name = property->property_name;
+
+ if (!style->rc_properties)
+ style->rc_properties = g_array_new (FALSE, FALSE, sizeof (GtkRcProperty));
+
+ i = 0;
+ while (i < style->rc_properties->len)
+ {
+ gint cmp = gtk_rc_properties_cmp (&key, &g_array_index (style->rc_properties, GtkRcProperty, i));
+
+ if (cmp == 0)
+ {
+ if (replace)
+ {
+ new_property = &g_array_index (style->rc_properties, GtkRcProperty, i);
+
+ g_free (new_property->origin);
+ g_value_unset (&new_property->value);
+
+ *new_property = key;
+ break;
+ }
+ else
+ return;
+ }
+ else if (cmp < 0)
+ break;
+
+ i++;
+ }
+
+ if (!new_property)
+ {
+ g_array_insert_val (style->rc_properties, i, key);
+ new_property = &g_array_index (style->rc_properties, GtkRcProperty, i);
+ }
+
+ new_property->origin = g_strdup (property->origin);
+ g_value_init (&new_property->value, G_VALUE_TYPE (&property->value));
+ g_value_copy (&property->value, &new_property->value);
+}
+
+static void
+gtk_rc_style_real_merge (GtkRcStyle *dest,
+ GtkRcStyle *src)
+{
+ gint i;
+
+ for (i = 0; i < 5; i++)
+ {
+ if (!dest->bg_pixmap_name[i] && src->bg_pixmap_name[i])
+ dest->bg_pixmap_name[i] = g_strdup (src->bg_pixmap_name[i]);
+
+ if (!(dest->color_flags[i] & GTK_RC_FG) &&
+ src->color_flags[i] & GTK_RC_FG)
+ {
+ dest->fg[i] = src->fg[i];
+ dest->color_flags[i] |= GTK_RC_FG;
+ }
+ if (!(dest->color_flags[i] & GTK_RC_BG) &&
+ src->color_flags[i] & GTK_RC_BG)
+ {
+ dest->bg[i] = src->bg[i];
+ dest->color_flags[i] |= GTK_RC_BG;
+ }
+ if (!(dest->color_flags[i] & GTK_RC_TEXT) &&
+ src->color_flags[i] & GTK_RC_TEXT)
+ {
+ dest->text[i] = src->text[i];
+ dest->color_flags[i] |= GTK_RC_TEXT;
+ }
+ if (!(dest->color_flags[i] & GTK_RC_BASE) &&
+ src->color_flags[i] & GTK_RC_BASE)
+ {
+ dest->base[i] = src->base[i];
+ dest->color_flags[i] |= GTK_RC_BASE;
+ }
+ }
+
+ if (dest->xthickness < 0 && src->xthickness >= 0)
+ dest->xthickness = src->xthickness;
+ if (dest->ythickness < 0 && src->ythickness >= 0)
+ dest->ythickness = src->ythickness;
+
+ if (src->font_desc)
+ {
+ if (!dest->font_desc)
+ dest->font_desc = pango_font_description_copy (src->font_desc);
+ else
+ pango_font_description_merge (dest->font_desc, src->font_desc, FALSE);
+ }
+
+ if (src->rc_properties)
+ {
+ guint i;
+
+ for (i = 0; i < src->rc_properties->len; i++)
+ insert_rc_property (dest,
+ &g_array_index (src->rc_properties, GtkRcProperty, i),
+ FALSE);
+ }
+}
+
+static GtkStyle *
+gtk_rc_style_real_create_style (GtkRcStyle *rc_style)
+{
+ return gtk_style_new ();
+}
+
+/**
+ * gtk_rc_reset_styles:
+ * @settings: a #GtkSettings
+ *
+ * This function recomputes the styles for all widgets that use a
+ * particular #GtkSettings object. (There is one #GtkSettings object
+ * per #GdkScreen, see gtk_settings_get_for_screen()); It is useful
+ * when some global parameter has changed that affects the appearance
+ * of all widgets, because when a widget gets a new style, it will
+ * both redraw and recompute any cached information about its
+ * appearance. As an example, it is used when the default font size
+ * set by the operating system changes. Note that this function
+ * doesn't affect widgets that have a style set explicitely on them
+ * with gtk_widget_set_style().
+ *
+ * Since: 2.4
+ *
+ * Deprecated: 3.0: Use #GtkCssProvider instead.
+ **/
+void
+gtk_rc_reset_styles (GtkSettings *settings)
+{
+ gtk_style_context_reset_widgets (_gtk_settings_get_screen (settings));
+}
+
+/**
+ * gtk_rc_reparse_all_for_settings:
+ * @settings: a #GtkSettings
+ * @force_load: load whether or not anything changed
+ *
+ * If the modification time on any previously read file
+ * for the given #GtkSettings has changed, discard all style information
+ * and then reread all previously read RC files.
+ *
+ * Return value: %TRUE if the files were reread.
+ *
+ * Deprecated: 3.0: Use #GtkCssProvider instead.
+ **/
+gboolean
+gtk_rc_reparse_all_for_settings (GtkSettings *settings,
+ gboolean force_load)
+{
+ return FALSE;
+}
+
+/**
+ * gtk_rc_reparse_all:
+ *
+ * If the modification time on any previously read file for the
+ * default #GtkSettings has changed, discard all style information
+ * and then reread all previously read RC files.
+ *
+ * Return value: %TRUE if the files were reread.
+ *
+ * Deprecated: 3.0: Use #GtkCssProvider instead.
+ **/
+gboolean
+gtk_rc_reparse_all (void)
+{
+ return FALSE;
+}
+
+/**
+ * gtk_rc_get_style:
+ * @widget: a #GtkWidget
+ *
+ * Finds all matching RC styles for a given widget,
+ * composites them together, and then creates a
+ * #GtkStyle representing the composite appearance.
+ * (GTK+ actually keeps a cache of previously
+ * created styles, so a new style may not be
+ * created.)
+ *
+ * Returns: (transfer none): the resulting style. No refcount is added
+ * to the returned style, so if you want to save this style around,
+ * you should add a reference yourself.
+ *
+ * Deprecated:3.0: Use #GtkStyleContext instead
+ **/
+GtkStyle *
+gtk_rc_get_style (GtkWidget *widget)
+{
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
+
+ gtk_widget_ensure_style (widget);
+
+ return gtk_widget_get_style (widget);
+}
+
+/**
+ * gtk_rc_get_style_by_paths:
+ * @settings: a #GtkSettings object
+ * @widget_path: (allow-none): the widget path to use when looking up the
+ * style, or %NULL if no matching against the widget path should be done
+ * @class_path: (allow-none): the class path to use when looking up the style,
+ * or %NULL if no matching against the class path should be done.
+ * @type: a type that will be used along with parent types of this type
+ * when matching against class styles, or #G_TYPE_NONE
+ *
+ * Creates up a #GtkStyle from styles defined in a RC file by providing
+ * the raw components used in matching. This function may be useful
+ * when creating pseudo-widgets that should be themed like widgets but
+ * don't actually have corresponding GTK+ widgets. An example of this
+ * would be items inside a GNOME canvas widget.
+ *
+ * The action of gtk_rc_get_style() is similar to:
+ * |[
+ * gtk_widget_path (widget, NULL, &path, NULL);
+ * gtk_widget_class_path (widget, NULL, &class_path, NULL);
+ * gtk_rc_get_style_by_paths (gtk_widget_get_settings (widget),
+ * path, class_path,
+ * G_OBJECT_TYPE (widget));
+ * ]|
+ *
+ * Return value: (transfer none): A style created by matching with the
+ * supplied paths, or %NULL if nothing matching was specified and the
+ * default style should be used. The returned value is owned by GTK+
+ * as part of an internal cache, so you must call g_object_ref() on
+ * the returned value if you want to keep a reference to it.
+ *
+ * Deprecated:3.0: Use #GtkStyleContext instead
+ **/
+GtkStyle *
+gtk_rc_get_style_by_paths (GtkSettings *settings,
+ const char *widget_path,
+ const char *class_path,
+ GType type)
+{
+ GtkWidgetPath *path;
+ GtkStyle *style;
+
+ path = gtk_widget_path_new ();
+
+ /* For compatibility, we return a GtkStyle based on a GtkStyleContext
+ * with a GtkWidgetPath appropriate for the supplied information.
+ *
+ * GtkWidgetPath is composed of a list of GTypes with optional names;
+ * In GTK+-2.0, widget_path consisted of the widget names, or
+ * the class names for unnamed widgets, while class_path had the
+ * class names always. So, use class_path to determine the GTypes
+ * and extract widget names from widget_path as applicable.
+ */
+ if (class_path == NULL)
+ {
+ gtk_widget_path_append_type (path, type == G_TYPE_NONE ? GTK_TYPE_WIDGET : type);
+ }
+ else
+ {
+ const gchar *widget_p, *widget_next;
+ const gchar *class_p, *class_next;
+
+ widget_next = widget_path;
+ class_next = class_path;
+
+ while (*class_next)
+ {
+ GType component_type;
+ gchar *component_class;
+ gchar *component_name;
+ gint pos;
+
+ class_p = class_next;
+ if (*class_p == '.')
+ class_p++;
+
+ widget_p = widget_next; /* Might be NULL */
+ if (widget_p && *widget_p == '.')
+ widget_p++;
+
+ class_next = strchr (class_p, '.');
+ if (class_next == NULL)
+ class_next = class_p + strlen (class_p);
+
+ if (widget_p)
+ {
+ widget_next = strchr (widget_p, '.');
+ if (widget_next == NULL)
+ widget_next = widget_p + strlen (widget_p);
+ }
+
+ component_class = g_strndup (class_p, class_next - class_p);
+ if (widget_p && *widget_p)
+ component_name = g_strndup (widget_p, widget_next - widget_p);
+ else
+ component_name = NULL;
+
+ component_type = g_type_from_name (component_class);
+ if (component_type == G_TYPE_INVALID)
+ component_type = GTK_TYPE_WIDGET;
+
+ pos = gtk_widget_path_append_type (path, component_type);
+ if (component_name != NULL && strcmp (component_name, component_name) != 0)
+ gtk_widget_path_iter_set_name (path, pos, component_name);
+
+ g_free (component_class);
+ g_free (component_name);
+ }
+ }
+
+ style = _gtk_style_new_for_path (_gtk_settings_get_screen (settings),
+ path);
+
+ gtk_widget_path_free (path);
+
+ return style;
+}
+
+/**
+ * gtk_rc_scanner_new: (skip)
+ *
+ * Deprecated:3.0: Use #GtkCssProvider instead
+ */
+GScanner*
+gtk_rc_scanner_new (void)
+{
+ return g_scanner_new (>k_rc_scanner_config);
+}
+
+/*********************
+ * Parsing functions *
+ *********************/
+
+static gboolean
+lookup_color (GtkRcStyle *style,
+ const char *color_name,
+ GdkColor *color)
+{
+ GtkRcStylePrivate *priv = GTK_RC_STYLE_GET_PRIVATE (style);
+ GSList *iter;
+
+ for (iter = priv->color_hashes; iter != NULL; iter = iter->next)
+ {
+ GHashTable *hash = iter->data;
+ GdkColor *match = g_hash_table_lookup (hash, color_name);
+
+ if (match)
+ {
+ color->red = match->red;
+ color->green = match->green;
+ color->blue = match->blue;
+ return TRUE;
+ }
+ }
+
+ return FALSE;
+}
+
+/**
+ * gtk_rc_find_pixmap_in_path:
+ * @settings: a #GtkSettings
+ * @scanner: Scanner used to get line number information for the
+ * warning message, or %NULL
+ * @pixmap_file: name of the pixmap file to locate.
+ *
+ * Looks up a file in pixmap path for the specified #GtkSettings.
+ * If the file is not found, it outputs a warning message using
+ * g_warning() and returns %NULL.
+ *
+ * Return value: (type filename): the filename.
+ *
+ * Deprecated: 3.0: Use #GtkCssProvider instead.
+ **/
+gchar*
+gtk_rc_find_pixmap_in_path (GtkSettings *settings,
+ GScanner *scanner,
+ const gchar *pixmap_file)
+{
+ g_warning ("Unable to locate image file in pixmap_path: \"%s\"",
+ pixmap_file);
+ return NULL;
+}
+
+/**
+ * gtk_rc_find_module_in_path:
+ * @module_file: name of a theme engine
+ *
+ * Searches for a theme engine in the GTK+ search path. This function
+ * is not useful for applications and should not be used.
+ *
+ * Return value: (type filename): The filename, if found (must be
+ * freed with g_free()), otherwise %NULL.
+ *
+ * Deprecated: 3.0: Use #GtkCssProvider instead.
+ **/
+gchar*
+gtk_rc_find_module_in_path (const gchar *module_file)
+{
+ return _gtk_find_module (module_file, "engines");
+}
+
+/**
+ * gtk_rc_parse_state:
+ * @scanner: a #GtkScanner (must be initialized for parsing an RC file)
+ * @state: (out): A pointer to a #GtkStateType variable in which to
+ * store the result.
+ *
+ * Parses a #GtkStateType variable from the format expected
+ * in a RC file.
+ *
+ * Returns: %G_TOKEN_NONE if parsing succeeded, otherwise the token
+ * that was expected but not found.
+ *
+ * Deprecated: 3.0: Use #GtkCssProvider instead
+ */
+guint
+gtk_rc_parse_state (GScanner *scanner,
+ GtkStateType *state)
+{
+ guint old_scope;
+ guint token;
+
+ g_return_val_if_fail (scanner != NULL, G_TOKEN_ERROR);
+ g_return_val_if_fail (state != NULL, G_TOKEN_ERROR);
+
+ /* we don't know where we got called from, so we reset the scope here.
+ * if we bail out due to errors, we *don't* reset the scope, so the
+ * error messaging code can make sense of our tokens.
+ */
+ old_scope = g_scanner_set_scope (scanner, 0);
+
+ token = g_scanner_get_next_token (scanner);
+ if (token != G_TOKEN_LEFT_BRACE)
+ return G_TOKEN_LEFT_BRACE;
+
+ token = g_scanner_get_next_token (scanner);
+ switch (token)
+ {
+ case GTK_RC_TOKEN_ACTIVE:
+ *state = GTK_STATE_ACTIVE;
+ break;
+ case GTK_RC_TOKEN_INSENSITIVE:
+ *state = GTK_STATE_INSENSITIVE;
+ break;
+ case GTK_RC_TOKEN_NORMAL:
+ *state = GTK_STATE_NORMAL;
+ break;
+ case GTK_RC_TOKEN_PRELIGHT:
+ *state = GTK_STATE_PRELIGHT;
+ break;
+ case GTK_RC_TOKEN_SELECTED:
+ *state = GTK_STATE_SELECTED;
+ break;
+ default:
+ return /* G_TOKEN_SYMBOL */ GTK_RC_TOKEN_NORMAL;
+ }
+
+ token = g_scanner_get_next_token (scanner);
+ if (token != G_TOKEN_RIGHT_BRACE)
+ return G_TOKEN_RIGHT_BRACE;
+
+ g_scanner_set_scope (scanner, old_scope);
+
+ return G_TOKEN_NONE;
+}
+
+/**
+ * gtk_rc_parse_priority:
+ * @scanner: a #GtkScanner (must be initialized for parsing an RC file)
+ * @priority: A pointer to #GtkPathPriorityType variable in which
+ * to store the result.
+ *
+ * Parses a #GtkPathPriorityType variable from the format expected
+ * in a RC file.
+ *
+ * Returns: %G_TOKEN_NONE if parsing succeeded, otherwise the token
+ * that was expected but not found.
+ *
+ * Deprecated:3.0: Use #GtkCssProvider instead
+ */
+guint
+gtk_rc_parse_priority (GScanner *scanner,
+ GtkPathPriorityType *priority)
+{
+ guint old_scope;
+ guint token;
+
+ g_return_val_if_fail (scanner != NULL, G_TOKEN_ERROR);
+ g_return_val_if_fail (priority != NULL, G_TOKEN_ERROR);
+
+ /* we don't know where we got called from, so we reset the scope here.
+ * if we bail out due to errors, we *don't* reset the scope, so the
+ * error messaging code can make sense of our tokens.
+ */
+ old_scope = g_scanner_set_scope (scanner, 0);
+
+ token = g_scanner_get_next_token (scanner);
+ if (token != ':')
+ return ':';
+
+ token = g_scanner_get_next_token (scanner);
+ switch (token)
+ {
+ case GTK_RC_TOKEN_LOWEST:
+ *priority = GTK_PATH_PRIO_LOWEST;
+ break;
+ case GTK_RC_TOKEN_GTK:
+ *priority = GTK_PATH_PRIO_GTK;
+ break;
+ case GTK_RC_TOKEN_APPLICATION:
+ *priority = GTK_PATH_PRIO_APPLICATION;
+ break;
+ case GTK_RC_TOKEN_THEME:
+ *priority = GTK_PATH_PRIO_THEME;
+ break;
+ case GTK_RC_TOKEN_RC:
+ *priority = GTK_PATH_PRIO_RC;
+ break;
+ case GTK_RC_TOKEN_HIGHEST:
+ *priority = GTK_PATH_PRIO_HIGHEST;
+ break;
+ default:
+ return /* G_TOKEN_SYMBOL */ GTK_RC_TOKEN_APPLICATION;
+ }
+
+ g_scanner_set_scope (scanner, old_scope);
+
+ return G_TOKEN_NONE;
+}
+
+/**
+ * gtk_rc_parse_color:
+ * @scanner: a #GScanner
+ * @color: (out): a pointer to a #GdkColor structure in which to store
+ * the result
+ *
+ * Parses a color in the <link linkend="color=format">format</link> expected
+ * in a RC file.
+ *
+ * Note that theme engines should use gtk_rc_parse_color_full() in
+ * order to support symbolic colors.
+ *
+ * Returns: %G_TOKEN_NONE if parsing succeeded, otherwise the token
+ * that was expected but not found
+ *
+ * Deprecated:3.0: Use #GtkCssProvider instead
+ */
+guint
+gtk_rc_parse_color (GScanner *scanner,
+ GdkColor *color)
+{
+ return gtk_rc_parse_color_full (scanner, NULL, color);
+}
+
+/**
+ * gtk_rc_parse_color_full:
+ * @scanner: a #GScanner
+ * @style: (allow-none): a #GtkRcStyle, or %NULL
+ * @color: (out): a pointer to a #GdkColor structure in which to store
+ * the result
+ *
+ * Parses a color in the <link linkend="color=format">format</link> expected
+ * in a RC file. If @style is not %NULL, it will be consulted to resolve
+ * references to symbolic colors.
+ *
+ * Returns: %G_TOKEN_NONE if parsing succeeded, otherwise the token
+ * that was expected but not found
+ *
+ * Since: 2.12
+ *
+ * Deprecated:3.0: Use #GtkCssProvider instead
+ */
+guint
+gtk_rc_parse_color_full (GScanner *scanner,
+ GtkRcStyle *style,
+ GdkColor *color)
+{
+ guint token;
+
+ g_return_val_if_fail (scanner != NULL, G_TOKEN_ERROR);
+
+ /* we don't need to set our own scope here, because
+ * we don't need own symbols
+ */
+
+ token = g_scanner_get_next_token (scanner);
+ switch (token)
+ {
+ gint token_int;
+ GdkColor c1, c2;
+ gboolean negate;
+ gdouble l;
+
+ case G_TOKEN_LEFT_CURLY:
+ token = g_scanner_get_next_token (scanner);
+ if (token == G_TOKEN_INT)
+ token_int = scanner->value.v_int;
+ else if (token == G_TOKEN_FLOAT)
+ token_int = scanner->value.v_float * 65535.0;
+ else
+ return G_TOKEN_FLOAT;
+ color->red = CLAMP (token_int, 0, 65535);
+
+ token = g_scanner_get_next_token (scanner);
+ if (token != G_TOKEN_COMMA)
+ return G_TOKEN_COMMA;
+
+ token = g_scanner_get_next_token (scanner);
+ if (token == G_TOKEN_INT)
+ token_int = scanner->value.v_int;
+ else if (token == G_TOKEN_FLOAT)
+ token_int = scanner->value.v_float * 65535.0;
+ else
+ return G_TOKEN_FLOAT;
+ color->green = CLAMP (token_int, 0, 65535);
+
+ token = g_scanner_get_next_token (scanner);
+ if (token != G_TOKEN_COMMA)
+ return G_TOKEN_COMMA;
+
+ token = g_scanner_get_next_token (scanner);
+ if (token == G_TOKEN_INT)
+ token_int = scanner->value.v_int;
+ else if (token == G_TOKEN_FLOAT)
+ token_int = scanner->value.v_float * 65535.0;
+ else
+ return G_TOKEN_FLOAT;
+ color->blue = CLAMP (token_int, 0, 65535);
+
+ token = g_scanner_get_next_token (scanner);
+ if (token != G_TOKEN_RIGHT_CURLY)
+ return G_TOKEN_RIGHT_CURLY;
+ return G_TOKEN_NONE;
+
+ case G_TOKEN_STRING:
+ if (!gdk_color_parse (scanner->value.v_string, color))
+ {
+ g_scanner_warn (scanner, "Invalid color constant '%s'",
+ scanner->value.v_string);
+ return G_TOKEN_STRING;
+ }
+ return G_TOKEN_NONE;
+
+ case '@':
+ token = g_scanner_get_next_token (scanner);
+ if (token != G_TOKEN_IDENTIFIER)
+ return G_TOKEN_IDENTIFIER;
+
+ if (!style || !lookup_color (style, scanner->value.v_identifier, color))
+ {
+ g_scanner_warn (scanner, "Invalid symbolic color '%s'",
+ scanner->value.v_identifier);
+ return G_TOKEN_IDENTIFIER;
+ }
+
+ return G_TOKEN_NONE;
+
+ case G_TOKEN_IDENTIFIER:
+ if (strcmp (scanner->value.v_identifier, "mix") == 0)
+ {
+ token = g_scanner_get_next_token (scanner);
+ if (token != G_TOKEN_LEFT_PAREN)
+ return G_TOKEN_LEFT_PAREN;
+
+ negate = FALSE;
+ if (g_scanner_peek_next_token (scanner) == '-')
+ {
+ g_scanner_get_next_token (scanner); /* eat sign */
+ negate = TRUE;
+ }
+
+ token = g_scanner_get_next_token (scanner);
+ if (token != G_TOKEN_FLOAT)
+ return G_TOKEN_FLOAT;
+
+ l = negate ? -scanner->value.v_float : scanner->value.v_float;
+
+ token = g_scanner_get_next_token (scanner);
+ if (token != G_TOKEN_COMMA)
+ return G_TOKEN_COMMA;
+
+ token = gtk_rc_parse_color_full (scanner, style, &c1);
+ if (token != G_TOKEN_NONE)
+ return token;
+
+ token = g_scanner_get_next_token (scanner);
+ if (token != G_TOKEN_COMMA)
+ return G_TOKEN_COMMA;
+
+ token = gtk_rc_parse_color_full (scanner, style, &c2);
+ if (token != G_TOKEN_NONE)
+ return token;
+
+ token = g_scanner_get_next_token (scanner);
+ if (token != G_TOKEN_RIGHT_PAREN)
+ return G_TOKEN_RIGHT_PAREN;
+
+ color->red = l * c1.red + (1.0 - l) * c2.red;
+ color->green = l * c1.green + (1.0 - l) * c2.green;
+ color->blue = l * c1.blue + (1.0 - l) * c2.blue;
+
+ return G_TOKEN_NONE;
+ }
+ else if (strcmp (scanner->value.v_identifier, "shade") == 0)
+ {
+ token = g_scanner_get_next_token (scanner);
+ if (token != G_TOKEN_LEFT_PAREN)
+ return G_TOKEN_LEFT_PAREN;
+
+ negate = FALSE;
+ if (g_scanner_peek_next_token (scanner) == '-')
+ {
+ g_scanner_get_next_token (scanner); /* eat sign */
+ negate = TRUE;
+ }
+
+ token = g_scanner_get_next_token (scanner);
+ if (token != G_TOKEN_FLOAT)
+ return G_TOKEN_FLOAT;
+
+ l = negate ? -scanner->value.v_float : scanner->value.v_float;
+
+ token = g_scanner_get_next_token (scanner);
+ if (token != G_TOKEN_COMMA)
+ return G_TOKEN_COMMA;
+
+ token = gtk_rc_parse_color_full (scanner, style, &c1);
+ if (token != G_TOKEN_NONE)
+ return token;
+
+ token = g_scanner_get_next_token (scanner);
+ if (token != G_TOKEN_RIGHT_PAREN)
+ return G_TOKEN_RIGHT_PAREN;
+
+ _gtk_style_shade (&c1, color, l);
+
+ return G_TOKEN_NONE;
+ }
+ else if (strcmp (scanner->value.v_identifier, "lighter") == 0 ||
+ strcmp (scanner->value.v_identifier, "darker") == 0)
+ {
+ if (scanner->value.v_identifier[0] == 'l')
+ l = 1.3;
+ else
+ l = 0.7;
+
+ token = g_scanner_get_next_token (scanner);
+ if (token != G_TOKEN_LEFT_PAREN)
+ return G_TOKEN_LEFT_PAREN;
+
+ token = gtk_rc_parse_color_full (scanner, style, &c1);
+ if (token != G_TOKEN_NONE)
+ return token;
+
+ token = g_scanner_get_next_token (scanner);
+ if (token != G_TOKEN_RIGHT_PAREN)
+ return G_TOKEN_RIGHT_PAREN;
+
+ _gtk_style_shade (&c1, color, l);
+
+ return G_TOKEN_NONE;
+ }
+ else
+ return G_TOKEN_IDENTIFIER;
+
+ default:
+ return G_TOKEN_STRING;
+ }
+}
--- /dev/null
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
+ * file for a list of people on the GTK+ Team. See the ChangeLog
+ * files for a list of changes. These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
+ */
+
+#if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
+#error "Only <gtk/gtk.h> can be included directly."
+#endif
+
+#ifndef __GTK_RC_H__
+#define __GTK_RC_H__
+
+#include <gtk/gtkwidget.h>
+
+G_BEGIN_DECLS
+
+/* Forward declarations */
+typedef struct _GtkRcContext GtkRcContext;
+typedef struct _GtkRcStyleClass GtkRcStyleClass;
+
+#define GTK_TYPE_RC_STYLE (gtk_rc_style_get_type ())
+#define GTK_RC_STYLE(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GTK_TYPE_RC_STYLE, GtkRcStyle))
+#define GTK_RC_STYLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_RC_STYLE, GtkRcStyleClass))
+#define GTK_IS_RC_STYLE(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GTK_TYPE_RC_STYLE))
+#define GTK_IS_RC_STYLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_RC_STYLE))
+#define GTK_RC_STYLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_RC_STYLE, GtkRcStyleClass))
+
+typedef enum
+{
+ GTK_RC_FG = 1 << 0,
+ GTK_RC_BG = 1 << 1,
+ GTK_RC_TEXT = 1 << 2,
+ GTK_RC_BASE = 1 << 3
+} GtkRcFlags;
+
+/**
+ * GtkRcStyle:
+ * @name:
+ * @bg_pixmap_name:
+ * @font_desc:
+ * @color_flags:
+ * @fg:
+ * @bg:
+ * @text:
+ * @base:
+ * @xthickness:
+ * @ythickness:
+ *
+ * The #GtkRcStyle structure is used to represent a set
+ * of information about the appearance of a widget.
+ * This can later be composited together with other
+ * #GtkRcStyle structures to form a #GtkStyle.
+ */
+struct _GtkRcStyle
+{
+ GObject parent_instance;
+
+ /*< public >*/
+
+ gchar *name;
+ gchar *bg_pixmap_name[5];
+ PangoFontDescription *font_desc;
+
+ GtkRcFlags color_flags[5];
+ GdkColor fg[5];
+ GdkColor bg[5];
+ GdkColor text[5];
+ GdkColor base[5];
+
+ gint xthickness;
+ gint ythickness;
+
+ /*< private >*/
+ GArray *rc_properties;
+
+ /* list of RC style lists including this RC style */
+ GSList *rc_style_lists;
+
+ GSList *icon_factories;
+
+ guint engine_specified : 1; /* The RC file specified the engine */
+};
+
+struct _GtkRcStyleClass
+{
+ GObjectClass parent_class;
+
+ /* Create an empty RC style of the same type as this RC style.
+ * The default implementation, which does
+ * g_object_new (G_OBJECT_TYPE (style), NULL);
+ * should work in most cases.
+ */
+ GtkRcStyle * (*create_rc_style) (GtkRcStyle *rc_style);
+
+ /* Fill in engine specific parts of GtkRcStyle by parsing contents
+ * of brackets. Returns G_TOKEN_NONE if successful, otherwise returns
+ * the token it expected but didn't get.
+ */
+ guint (*parse) (GtkRcStyle *rc_style,
+ GtkSettings *settings,
+ GScanner *scanner);
+
+ /* Combine RC style data from src into dest. If overridden, this
+ * function should chain to the parent.
+ */
+ void (*merge) (GtkRcStyle *dest,
+ GtkRcStyle *src);
+
+ /* Create an empty style suitable to this RC style
+ */
+ GtkStyle * (*create_style) (GtkRcStyle *rc_style);
+
+ /* Padding for future expansion */
+ void (*_gtk_reserved1) (void);
+ void (*_gtk_reserved2) (void);
+ void (*_gtk_reserved3) (void);
+ void (*_gtk_reserved4) (void);
+};
+
+GSList* _gtk_rc_parse_widget_class_path (const gchar *pattern);
+void _gtk_rc_free_widget_class_path (GSList *list);
+gboolean _gtk_rc_match_widget_class (GSList *list,
+ gint length,
+ gchar *path,
+ gchar *path_reversed);
+
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_rc_add_default_file (const gchar *filename);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_rc_set_default_files (gchar **filenames);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+gchar** gtk_rc_get_default_files (void);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+GtkStyle* gtk_rc_get_style (GtkWidget *widget);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+GtkStyle* gtk_rc_get_style_by_paths (GtkSettings *settings,
+ const char *widget_path,
+ const char *class_path,
+ GType type);
+
+GDK_DEPRECATED_FOR(GtkStyleContext)
+gboolean gtk_rc_reparse_all_for_settings (GtkSettings *settings,
+ gboolean force_load);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_rc_reset_styles (GtkSettings *settings);
+
+GDK_DEPRECATED_FOR(GtkStyleContext)
+gchar* gtk_rc_find_pixmap_in_path (GtkSettings *settings,
+ GScanner *scanner,
+ const gchar *pixmap_file);
+
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_rc_parse (const gchar *filename);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_rc_parse_string (const gchar *rc_string);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+gboolean gtk_rc_reparse_all (void);
+
+GType gtk_rc_style_get_type (void) G_GNUC_CONST;
+GDK_DEPRECATED_FOR(GtkStyleContext)
+GtkRcStyle* gtk_rc_style_new (void);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+GtkRcStyle* gtk_rc_style_copy (GtkRcStyle *orig);
+
+GDK_DEPRECATED_FOR(GtkStyleContext)
+gchar* gtk_rc_find_module_in_path (const gchar *module_file);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+gchar* gtk_rc_get_theme_dir (void);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+gchar* gtk_rc_get_module_dir (void);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+gchar* gtk_rc_get_im_module_path (void);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+gchar* gtk_rc_get_im_module_file (void);
+
+/* private functions/definitions */
+
+/**
+ * GtkRcTokenType:
+ * @GTK_RC_TOKEN_INVALID:
+ * @GTK_RC_TOKEN_INCLUDE:
+ * @GTK_RC_TOKEN_NORMAL:
+ * @GTK_RC_TOKEN_ACTIVE:
+ * @GTK_RC_TOKEN_PRELIGHT:
+ * @GTK_RC_TOKEN_SELECTED:
+ * @GTK_RC_TOKEN_INSENSITIVE:
+ * @GTK_RC_TOKEN_FG:
+ * @GTK_RC_TOKEN_BG:
+ * @GTK_RC_TOKEN_TEXT:
+ * @GTK_RC_TOKEN_BASE:
+ * @GTK_RC_TOKEN_XTHICKNESS:
+ * @GTK_RC_TOKEN_YTHICKNESS:
+ * @GTK_RC_TOKEN_FONT:
+ * @GTK_RC_TOKEN_FONTSET:
+ * @GTK_RC_TOKEN_FONT_NAME:
+ * @GTK_RC_TOKEN_BG_PIXMAP:
+ * @GTK_RC_TOKEN_PIXMAP_PATH:
+ * @GTK_RC_TOKEN_STYLE:
+ * @GTK_RC_TOKEN_BINDING:
+ * @GTK_RC_TOKEN_BIND:
+ * @GTK_RC_TOKEN_WIDGET:
+ * @GTK_RC_TOKEN_WIDGET_CLASS:
+ * @GTK_RC_TOKEN_CLASS:
+ * @GTK_RC_TOKEN_LOWEST:
+ * @GTK_RC_TOKEN_GTK:
+ * @GTK_RC_TOKEN_APPLICATION:
+ * @GTK_RC_TOKEN_THEME:
+ * @GTK_RC_TOKEN_RC:
+ * @GTK_RC_TOKEN_HIGHEST:
+ * @GTK_RC_TOKEN_ENGINE:
+ * @GTK_RC_TOKEN_MODULE_PATH:
+ * @GTK_RC_TOKEN_IM_MODULE_PATH:
+ * @GTK_RC_TOKEN_IM_MODULE_FILE:
+ * @GTK_RC_TOKEN_STOCK:
+ * @GTK_RC_TOKEN_LTR:
+ * @GTK_RC_TOKEN_RTL:
+ * @GTK_RC_TOKEN_COLOR:
+ * @GTK_RC_TOKEN_UNBIND:
+ * @GTK_RC_TOKEN_LAST:
+ *
+ * The #GtkRcTokenType enumeration represents the tokens
+ * in the RC file. It is exposed so that theme engines
+ * can reuse these tokens when parsing the theme-engine
+ * specific portions of a RC file.
+ *
+ * Deprecated: 3.0: Use #GtkCssProvider instead.
+ */
+typedef enum {
+ GTK_RC_TOKEN_INVALID = G_TOKEN_LAST,
+ GTK_RC_TOKEN_INCLUDE,
+ GTK_RC_TOKEN_NORMAL,
+ GTK_RC_TOKEN_ACTIVE,
+ GTK_RC_TOKEN_PRELIGHT,
+ GTK_RC_TOKEN_SELECTED,
+ GTK_RC_TOKEN_INSENSITIVE,
+ GTK_RC_TOKEN_FG,
+ GTK_RC_TOKEN_BG,
+ GTK_RC_TOKEN_TEXT,
+ GTK_RC_TOKEN_BASE,
+ GTK_RC_TOKEN_XTHICKNESS,
+ GTK_RC_TOKEN_YTHICKNESS,
+ GTK_RC_TOKEN_FONT,
+ GTK_RC_TOKEN_FONTSET,
+ GTK_RC_TOKEN_FONT_NAME,
+ GTK_RC_TOKEN_BG_PIXMAP,
+ GTK_RC_TOKEN_PIXMAP_PATH,
+ GTK_RC_TOKEN_STYLE,
+ GTK_RC_TOKEN_BINDING,
+ GTK_RC_TOKEN_BIND,
+ GTK_RC_TOKEN_WIDGET,
+ GTK_RC_TOKEN_WIDGET_CLASS,
+ GTK_RC_TOKEN_CLASS,
+ GTK_RC_TOKEN_LOWEST,
+ GTK_RC_TOKEN_GTK,
+ GTK_RC_TOKEN_APPLICATION,
+ GTK_RC_TOKEN_THEME,
+ GTK_RC_TOKEN_RC,
+ GTK_RC_TOKEN_HIGHEST,
+ GTK_RC_TOKEN_ENGINE,
+ GTK_RC_TOKEN_MODULE_PATH,
+ GTK_RC_TOKEN_IM_MODULE_PATH,
+ GTK_RC_TOKEN_IM_MODULE_FILE,
+ GTK_RC_TOKEN_STOCK,
+ GTK_RC_TOKEN_LTR,
+ GTK_RC_TOKEN_RTL,
+ GTK_RC_TOKEN_COLOR,
+ GTK_RC_TOKEN_UNBIND,
+ GTK_RC_TOKEN_LAST
+} GtkRcTokenType;
+
+GDK_DEPRECATED_FOR(GtkStyleContext)
+GScanner* gtk_rc_scanner_new (void);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+guint gtk_rc_parse_color (GScanner *scanner,
+ GdkColor *color);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+guint gtk_rc_parse_color_full (GScanner *scanner,
+ GtkRcStyle *style,
+ GdkColor *color);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+guint gtk_rc_parse_state (GScanner *scanner,
+ GtkStateType *state);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+guint gtk_rc_parse_priority (GScanner *scanner,
+ GtkPathPriorityType *priority);
+
+/* rc properties
+ * (structure forward declared in gtkstyle.h)
+ */
+struct _GtkRcProperty
+{
+ /* quark-ified property identifier like "GtkScrollbar::spacing" */
+ GQuark type_name;
+ GQuark property_name;
+
+ /* fields similar to GtkSettingsValue */
+ gchar *origin;
+ GValue value;
+};
+
+G_END_DECLS
+
+#endif /* __GTK_RC_H__ */
--- /dev/null
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
+ * file for a list of people on the GTK+ Team. See the ChangeLog
+ * files for a list of changes. These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
+ */
+
+#include "config.h"
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+#include <gobject/gvaluecollector.h>
+#include "gtkmarshalers.h"
+#include "gtkpango.h"
+#include "gtkrc.h"
+#include "gtkspinbutton.h"
+#include "gtkstyle.h"
+#include "gtkstylecontextprivate.h"
+#include "gtkwidget.h"
+#include "gtkiconfactory.h"
+#include "gtkintl.h"
+#include "gtkdebug.h"
+#include "gtkspinner.h"
+#include "gtkborder.h"
+
+/**
+ * SECTION:gtkstyle
+ * @Short_description: Deprecated object that holds style information
+ * for widgets
+ * @Title: GtkStyle
+ *
+ * A #GtkStyle object encapsulates the information that provides the look and
+ * feel for a widget.
+ *
+ * <warning>
+ * In GTK+ 3.0, GtkStyle has been deprecated and replaced by #GtkStyleContext.
+ * </warning>
+ *
+ * Each #GtkWidget has an associated #GtkStyle object that is used when
+ * rendering that widget. Also, a #GtkStyle holds information for the five
+ * possible widget states though not every widget supports all five
+ * states; see #GtkStateType.
+ *
+ * Usually the #GtkStyle for a widget is the same as the default style that
+ * is set by GTK+ and modified the theme engine.
+ *
+ * Usually applications should not need to use or modify the #GtkStyle of
+ * their widgets.
+ */
+
+
+#define LIGHTNESS_MULT 1.3
+#define DARKNESS_MULT 0.7
+
+/* --- typedefs & structures --- */
+typedef struct {
+ GType widget_type;
+ GParamSpec *pspec;
+ GValue value;
+} PropertyValue;
+
+#define GTK_STYLE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_STYLE, GtkStylePrivate))
+
+typedef struct _GtkStylePrivate GtkStylePrivate;
+
+struct _GtkStylePrivate {
+ GtkStyleContext *context;
+ gulong context_changed_id;
+};
+
+enum {
+ PROP_0,
+ PROP_CONTEXT
+};
+
+/* --- prototypes --- */
+static void gtk_style_finalize (GObject *object);
+static void gtk_style_constructed (GObject *object);
+static void gtk_style_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec);
+static void gtk_style_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec);
+
+static void gtk_style_real_realize (GtkStyle *style);
+static void gtk_style_real_unrealize (GtkStyle *style);
+static void gtk_style_real_copy (GtkStyle *style,
+ GtkStyle *src);
+static void gtk_style_real_set_background (GtkStyle *style,
+ GdkWindow *window,
+ GtkStateType state_type);
+static GtkStyle *gtk_style_real_clone (GtkStyle *style);
+static void gtk_style_real_init_from_rc (GtkStyle *style,
+ GtkRcStyle *rc_style);
+static GdkPixbuf *gtk_default_render_icon (GtkStyle *style,
+ const GtkIconSource *source,
+ GtkTextDirection direction,
+ GtkStateType state,
+ GtkIconSize size,
+ GtkWidget *widget,
+ const gchar *detail);
+static void gtk_default_draw_hline (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x1,
+ gint x2,
+ gint y);
+static void gtk_default_draw_vline (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint y1,
+ gint y2,
+ gint x);
+static void gtk_default_draw_shadow (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+static void gtk_default_draw_arrow (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ GtkArrowType arrow_type,
+ gboolean fill,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+static void gtk_default_draw_diamond (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+static void gtk_default_draw_box (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+static void gtk_default_draw_flat_box (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+static void gtk_default_draw_check (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+static void gtk_default_draw_option (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+static void gtk_default_draw_tab (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+static void gtk_default_draw_shadow_gap (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ GtkPositionType gap_side,
+ gint gap_x,
+ gint gap_width);
+static void gtk_default_draw_box_gap (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ GtkPositionType gap_side,
+ gint gap_x,
+ gint gap_width);
+static void gtk_default_draw_extension (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ GtkPositionType gap_side);
+static void gtk_default_draw_focus (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+static void gtk_default_draw_slider (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ GtkOrientation orientation);
+static void gtk_default_draw_handle (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ GtkOrientation orientation);
+static void gtk_default_draw_expander (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ GtkExpanderStyle expander_style);
+static void gtk_default_draw_layout (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ gboolean use_text,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ PangoLayout *layout);
+static void gtk_default_draw_resize_grip (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ GdkWindowEdge edge,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+static void gtk_default_draw_spinner (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ guint step,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+
+static void rgb_to_hls (gdouble *r,
+ gdouble *g,
+ gdouble *b);
+static void hls_to_rgb (gdouble *h,
+ gdouble *l,
+ gdouble *s);
+
+static void transform_detail_string (const gchar *detail,
+ GtkStyleContext *context);
+
+/*
+ * Data for default check and radio buttons
+ */
+
+static const GtkRequisition default_option_indicator_size = { 7, 13 };
+static const GtkBorder default_option_indicator_spacing = { 7, 5, 2, 2 };
+
+#define GTK_GRAY 0xdcdc, 0xdada, 0xd5d5
+#define GTK_DARK_GRAY 0xc4c4, 0xc2c2, 0xbdbd
+#define GTK_LIGHT_GRAY 0xeeee, 0xebeb, 0xe7e7
+#define GTK_WHITE 0xffff, 0xffff, 0xffff
+#define GTK_BLUE 0x4b4b, 0x6969, 0x8383
+#define GTK_VERY_DARK_GRAY 0x9c9c, 0x9a9a, 0x9494
+#define GTK_BLACK 0x0000, 0x0000, 0x0000
+#define GTK_WEAK_GRAY 0x7530, 0x7530, 0x7530
+
+/* --- variables --- */
+static const GdkColor gtk_default_normal_fg = { 0, GTK_BLACK };
+static const GdkColor gtk_default_active_fg = { 0, GTK_BLACK };
+static const GdkColor gtk_default_prelight_fg = { 0, GTK_BLACK };
+static const GdkColor gtk_default_selected_fg = { 0, GTK_WHITE };
+static const GdkColor gtk_default_insensitive_fg = { 0, GTK_WEAK_GRAY };
+
+static const GdkColor gtk_default_normal_bg = { 0, GTK_GRAY };
+static const GdkColor gtk_default_active_bg = { 0, GTK_DARK_GRAY };
+static const GdkColor gtk_default_prelight_bg = { 0, GTK_LIGHT_GRAY };
+static const GdkColor gtk_default_selected_bg = { 0, GTK_BLUE };
+static const GdkColor gtk_default_insensitive_bg = { 0, GTK_GRAY };
+static const GdkColor gtk_default_selected_base = { 0, GTK_BLUE };
+static const GdkColor gtk_default_active_base = { 0, GTK_VERY_DARK_GRAY };
+
+/* --- signals --- */
+static guint realize_signal = 0;
+static guint unrealize_signal = 0;
+
+G_DEFINE_TYPE (GtkStyle, gtk_style, G_TYPE_OBJECT)
+
+/* --- functions --- */
+
+static void
+gtk_style_init (GtkStyle *style)
+{
+ gint i;
+
+ style->font_desc = pango_font_description_from_string ("Sans 10");
+
+ style->attach_count = 0;
+
+ style->black.red = 0;
+ style->black.green = 0;
+ style->black.blue = 0;
+
+ style->white.red = 65535;
+ style->white.green = 65535;
+ style->white.blue = 65535;
+
+ style->fg[GTK_STATE_NORMAL] = gtk_default_normal_fg;
+ style->fg[GTK_STATE_ACTIVE] = gtk_default_active_fg;
+ style->fg[GTK_STATE_PRELIGHT] = gtk_default_prelight_fg;
+ style->fg[GTK_STATE_SELECTED] = gtk_default_selected_fg;
+ style->fg[GTK_STATE_INSENSITIVE] = gtk_default_insensitive_fg;
+
+ style->bg[GTK_STATE_NORMAL] = gtk_default_normal_bg;
+ style->bg[GTK_STATE_ACTIVE] = gtk_default_active_bg;
+ style->bg[GTK_STATE_PRELIGHT] = gtk_default_prelight_bg;
+ style->bg[GTK_STATE_SELECTED] = gtk_default_selected_bg;
+ style->bg[GTK_STATE_INSENSITIVE] = gtk_default_insensitive_bg;
+
+ for (i = 0; i < 4; i++)
+ {
+ style->text[i] = style->fg[i];
+ style->base[i] = style->white;
+ }
+
+ style->base[GTK_STATE_SELECTED] = gtk_default_selected_base;
+ style->text[GTK_STATE_SELECTED] = style->white;
+ style->base[GTK_STATE_ACTIVE] = gtk_default_active_base;
+ style->text[GTK_STATE_ACTIVE] = style->white;
+ style->base[GTK_STATE_INSENSITIVE] = gtk_default_prelight_bg;
+ style->text[GTK_STATE_INSENSITIVE] = gtk_default_insensitive_fg;
+
+ style->rc_style = NULL;
+
+ style->xthickness = 2;
+ style->ythickness = 2;
+
+ style->property_cache = NULL;
+}
+
+static void
+gtk_style_class_init (GtkStyleClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+ object_class->finalize = gtk_style_finalize;
+ object_class->set_property = gtk_style_set_property;
+ object_class->get_property = gtk_style_get_property;
+ object_class->constructed = gtk_style_constructed;
+
+ klass->clone = gtk_style_real_clone;
+ klass->copy = gtk_style_real_copy;
+ klass->init_from_rc = gtk_style_real_init_from_rc;
+ klass->realize = gtk_style_real_realize;
+ klass->unrealize = gtk_style_real_unrealize;
+ klass->set_background = gtk_style_real_set_background;
+ klass->render_icon = gtk_default_render_icon;
+
+ klass->draw_hline = gtk_default_draw_hline;
+ klass->draw_vline = gtk_default_draw_vline;
+ klass->draw_shadow = gtk_default_draw_shadow;
+ klass->draw_arrow = gtk_default_draw_arrow;
+ klass->draw_diamond = gtk_default_draw_diamond;
+ klass->draw_box = gtk_default_draw_box;
+ klass->draw_flat_box = gtk_default_draw_flat_box;
+ klass->draw_check = gtk_default_draw_check;
+ klass->draw_option = gtk_default_draw_option;
+ klass->draw_tab = gtk_default_draw_tab;
+ klass->draw_shadow_gap = gtk_default_draw_shadow_gap;
+ klass->draw_box_gap = gtk_default_draw_box_gap;
+ klass->draw_extension = gtk_default_draw_extension;
+ klass->draw_focus = gtk_default_draw_focus;
+ klass->draw_slider = gtk_default_draw_slider;
+ klass->draw_handle = gtk_default_draw_handle;
+ klass->draw_expander = gtk_default_draw_expander;
+ klass->draw_layout = gtk_default_draw_layout;
+ klass->draw_resize_grip = gtk_default_draw_resize_grip;
+ klass->draw_spinner = gtk_default_draw_spinner;
+
+ g_type_class_add_private (object_class, sizeof (GtkStylePrivate));
+
+ g_object_class_install_property (object_class,
+ PROP_CONTEXT,
+ g_param_spec_object ("context",
+ P_("Style context"),
+ P_("GtkStyleContext to get style from"),
+ GTK_TYPE_STYLE_CONTEXT,
+ G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
+
+ /**
+ * GtkStyle::realize:
+ * @style: the object which received the signal
+ *
+ * Emitted when the style has been initialized for a particular
+ * visual. Connecting to this signal is probably seldom
+ * useful since most of the time applications and widgets only
+ * deal with styles that have been already realized.
+ *
+ * Since: 2.4
+ */
+ realize_signal = g_signal_new (I_("realize"),
+ G_TYPE_FROM_CLASS (object_class),
+ G_SIGNAL_RUN_FIRST,
+ G_STRUCT_OFFSET (GtkStyleClass, realize),
+ NULL, NULL,
+ _gtk_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+ /**
+ * GtkStyle::unrealize:
+ * @style: the object which received the signal
+ *
+ * Emitted when the aspects of the style specific to a particular visual
+ * is being cleaned up. A connection to this signal can be useful
+ * if a widget wants to cache objects as object data on #GtkStyle.
+ * This signal provides a convenient place to free such cached objects.
+ *
+ * Since: 2.4
+ */
+ unrealize_signal = g_signal_new (I_("unrealize"),
+ G_TYPE_FROM_CLASS (object_class),
+ G_SIGNAL_RUN_FIRST,
+ G_STRUCT_OFFSET (GtkStyleClass, unrealize),
+ NULL, NULL,
+ _gtk_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+}
+
+static void
+gtk_style_finalize (GObject *object)
+{
+ GtkStyle *style = GTK_STYLE (object);
+ GtkStylePrivate *priv = GTK_STYLE_GET_PRIVATE (style);
+ gint i;
+
+ g_return_if_fail (style->attach_count == 0);
+
+ /* All the styles in the list have the same
+ * style->styles pointer. If we delete the
+ * *first* style from the list, we need to update
+ * the style->styles pointers from all the styles.
+ * Otherwise we simply remove the node from
+ * the list.
+ */
+ if (style->styles)
+ {
+ if (style->styles->data != style)
+ style->styles = g_slist_remove (style->styles, style);
+ else
+ {
+ GSList *tmp_list = style->styles->next;
+
+ while (tmp_list)
+ {
+ GTK_STYLE (tmp_list->data)->styles = style->styles->next;
+ tmp_list = tmp_list->next;
+ }
+ g_slist_free_1 (style->styles);
+ }
+ }
+
+ g_slist_foreach (style->icon_factories, (GFunc) g_object_unref, NULL);
+ g_slist_free (style->icon_factories);
+
+ pango_font_description_free (style->font_desc);
+
+ if (style->private_font_desc)
+ pango_font_description_free (style->private_font_desc);
+
+ if (style->rc_style)
+ g_object_unref (style->rc_style);
+
+ if (priv->context)
+ {
+ if (priv->context_changed_id)
+ g_signal_handler_disconnect (priv->context, priv->context_changed_id);
+
+ g_object_unref (priv->context);
+ }
+
+ for (i = 0; i < 5; i++)
+ {
+ if (style->background[i])
+ cairo_pattern_destroy (style->background[i]);
+ }
+
+ G_OBJECT_CLASS (gtk_style_parent_class)->finalize (object);
+}
+
+static void
+gtk_style_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GtkStylePrivate *priv;
+
+ priv = GTK_STYLE_GET_PRIVATE (object);
+
+ switch (prop_id)
+ {
+ case PROP_CONTEXT:
+ priv->context = g_value_dup_object (value);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+gtk_style_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GtkStylePrivate *priv;
+
+ priv = GTK_STYLE_GET_PRIVATE (object);
+
+ switch (prop_id)
+ {
+ case PROP_CONTEXT:
+ g_value_set_object (value, priv->context);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+set_color (GtkStyle *style,
+ GtkStyleContext *context,
+ GtkStateType state,
+ GtkRcFlags prop)
+{
+ GtkStateFlags flags;
+ GdkRGBA *color = NULL;
+ GdkColor *dest = { 0 }; /* Shut up gcc */
+
+ switch (state)
+ {
+ case GTK_STATE_ACTIVE:
+ flags = GTK_STATE_FLAG_ACTIVE;
+ break;
+ case GTK_STATE_PRELIGHT:
+ flags = GTK_STATE_FLAG_PRELIGHT;
+ break;
+ case GTK_STATE_SELECTED:
+ flags = GTK_STATE_FLAG_SELECTED;
+ break;
+ case GTK_STATE_INSENSITIVE:
+ flags = GTK_STATE_FLAG_INSENSITIVE;
+ break;
+ default:
+ flags = 0;
+ }
+
+ switch (prop)
+ {
+ case GTK_RC_BG:
+ gtk_style_context_get (context, flags,
+ "background-color", &color,
+ NULL);
+ dest = &style->bg[state];
+ break;
+ case GTK_RC_FG:
+ gtk_style_context_get (context, flags,
+ "color", &color,
+ NULL);
+ dest = &style->fg[state];
+ break;
+ case GTK_RC_TEXT:
+ gtk_style_context_get (context, flags,
+ "color", &color,
+ NULL);
+ dest = &style->text[state];
+ break;
+ case GTK_RC_BASE:
+ gtk_style_context_get (context, flags,
+ "background-color", &color,
+ NULL);
+ dest = &style->base[state];
+ break;
+ }
+
+ if (color)
+ {
+ dest->pixel = 0;
+ dest->red = CLAMP ((guint) (color->red * 65535), 0, 65535);
+ dest->green = CLAMP ((guint) (color->green * 65535), 0, 65535);
+ dest->blue = CLAMP ((guint) (color->blue * 65535), 0, 65535);
+ gdk_rgba_free (color);
+ }
+}
+
+static void
+gtk_style_update_from_context (GtkStyle *style)
+{
+ GtkStylePrivate *priv;
+ GtkStateType state;
+ GtkBorder padding;
+ gint i;
+
+ priv = GTK_STYLE_GET_PRIVATE (style);
+
+ for (state = GTK_STATE_NORMAL; state <= GTK_STATE_INSENSITIVE; state++)
+ {
+ if (gtk_style_context_has_class (priv->context, "entry"))
+ {
+ gtk_style_context_save (priv->context);
+ gtk_style_context_remove_class (priv->context, "entry");
+ set_color (style, priv->context, state, GTK_RC_BG);
+ set_color (style, priv->context, state, GTK_RC_FG);
+ gtk_style_context_restore (priv->context);
+
+ set_color (style, priv->context, state, GTK_RC_BASE);
+ set_color (style, priv->context, state, GTK_RC_TEXT);
+ }
+ else
+ {
+ gtk_style_context_save (priv->context);
+ gtk_style_context_add_class (priv->context, "entry");
+ set_color (style, priv->context, state, GTK_RC_BASE);
+ set_color (style, priv->context, state, GTK_RC_TEXT);
+ gtk_style_context_restore (priv->context);
+
+ set_color (style, priv->context, state, GTK_RC_BG);
+ set_color (style, priv->context, state, GTK_RC_FG);
+ }
+ }
+
+ if (style->font_desc)
+ pango_font_description_free (style->font_desc);
+
+ gtk_style_context_get (priv->context, 0,
+ "font", &style->font_desc,
+ NULL);
+ gtk_style_context_get_padding (priv->context, 0, &padding);
+
+ style->xthickness = padding.left;
+ style->ythickness = padding.top;
+
+ for (i = 0; i < 5; i++)
+ {
+ _gtk_style_shade (&style->bg[i], &style->light[i], LIGHTNESS_MULT);
+ _gtk_style_shade (&style->bg[i], &style->dark[i], DARKNESS_MULT);
+
+ style->mid[i].red = (style->light[i].red + style->dark[i].red) / 2;
+ style->mid[i].green = (style->light[i].green + style->dark[i].green) / 2;
+ style->mid[i].blue = (style->light[i].blue + style->dark[i].blue) / 2;
+
+ style->text_aa[i].red = (style->text[i].red + style->base[i].red) / 2;
+ style->text_aa[i].green = (style->text[i].green + style->base[i].green) / 2;
+ style->text_aa[i].blue = (style->text[i].blue + style->base[i].blue) / 2;
+ }
+
+ style->black.red = 0x0000;
+ style->black.green = 0x0000;
+ style->black.blue = 0x0000;
+
+ style->white.red = 0xffff;
+ style->white.green = 0xffff;
+ style->white.blue = 0xffff;
+
+ for (i = 0; i < 5; i++)
+ {
+ if (style->background[i])
+ cairo_pattern_destroy (style->background[i]);
+
+ style->background[i] = cairo_pattern_create_rgb (style->bg[i].red / 65535.0,
+ style->bg[i].green / 65535.0,
+ style->bg[i].blue / 65535.0);
+ }
+}
+
+static void
+style_context_changed (GtkStyleContext *context,
+ gpointer user_data)
+{
+ gtk_style_update_from_context (GTK_STYLE (user_data));
+}
+
+static void
+gtk_style_constructed (GObject *object)
+{
+ GtkStylePrivate *priv;
+
+ priv = GTK_STYLE_GET_PRIVATE (object);
+
+ if (priv->context)
+ {
+ gtk_style_update_from_context (GTK_STYLE (object));
+
+ priv->context_changed_id = g_signal_connect (priv->context, "changed",
+ G_CALLBACK (style_context_changed), object);
+ }
+}
+
+/**
+ * gtk_style_copy:
+ * @style: a #GtkStyle
+ *
+ * Creates a copy of the passed in #GtkStyle object.
+ *
+ * Returns: (transfer full): a copy of @style
+ *
+ * Deprecated:3.0: Use #GtkStyleContext instead
+ */
+GtkStyle*
+gtk_style_copy (GtkStyle *style)
+{
+ GtkStyle *new_style;
+
+ g_return_val_if_fail (GTK_IS_STYLE (style), NULL);
+
+ new_style = GTK_STYLE_GET_CLASS (style)->clone (style);
+ GTK_STYLE_GET_CLASS (style)->copy (new_style, style);
+
+ return new_style;
+}
+
+GtkStyle*
+_gtk_style_new_for_path (GdkScreen *screen,
+ GtkWidgetPath *path)
+{
+ GtkStyleContext *context;
+ GtkStyle *style;
+
+ context = gtk_style_context_new ();
+
+ if (screen)
+ gtk_style_context_set_screen (context, screen);
+
+ gtk_style_context_set_path (context, path);
+
+ style = g_object_new (GTK_TYPE_STYLE,
+ "context", context,
+ NULL);
+
+ g_object_unref (context);
+
+ return style;
+}
+
+/**
+ * gtk_style_new:
+ *
+ * Creates a new #GtkStyle.
+ *
+ * Returns: a new #GtkStyle.
+ *
+ * Deprecated: 3.0: Use #GtkStyleContext
+ */
+GtkStyle*
+gtk_style_new (void)
+{
+ GtkWidgetPath *path;
+ GtkStyle *style;
+
+ path = gtk_widget_path_new ();
+ gtk_widget_path_append_type (path, GTK_TYPE_WIDGET);
+
+ style = _gtk_style_new_for_path (gdk_screen_get_default (), path);
+
+ gtk_widget_path_free (path);
+
+ return style;
+}
+
+/**
+ * gtk_style_has_context:
+ * @style: a #GtkStyle
+ *
+ * Returns whether @style has an associated #GtkStyleContext.
+ *
+ * Returns: %TRUE if @style has a #GtkStyleContext
+ *
+ * Since: 3.0
+ */
+gboolean
+gtk_style_has_context (GtkStyle *style)
+{
+ GtkStylePrivate *priv;
+
+ priv = GTK_STYLE_GET_PRIVATE (style);
+
+ return priv->context != NULL;
+}
+
+/**
+ * gtk_style_attach: (skip)
+ * @style: a #GtkStyle.
+ * @window: a #GdkWindow.
+ *
+ * Attaches a style to a window; this process allocates the
+ * colors and creates the GC's for the style - it specializes
+ * it to a particular visual. The process may involve the creation
+ * of a new style if the style has already been attached to a
+ * window with a different style and visual.
+ *
+ * Since this function may return a new object, you have to use it
+ * in the following way:
+ * <literal>style = gtk_style_attach (style, window)</literal>
+ *
+ * Returns: Either @style, or a newly-created #GtkStyle.
+ * If the style is newly created, the style parameter
+ * will be unref'ed, and the new style will have
+ * a reference count belonging to the caller.
+ *
+ * Deprecated:3.0: Use gtk_widget_style_attach() instead
+ */
+GtkStyle*
+gtk_style_attach (GtkStyle *style,
+ GdkWindow *window)
+{
+ g_return_val_if_fail (GTK_IS_STYLE (style), NULL);
+ g_return_val_if_fail (window != NULL, NULL);
+
+ return style;
+}
+
+/**
+ * gtk_style_detach:
+ * @style: a #GtkStyle
+ *
+ * Detaches a style from a window. If the style is not attached
+ * to any windows anymore, it is unrealized. See gtk_style_attach().
+ *
+ * Deprecated:3.0: Use #GtkStyleContext instead
+ */
+void
+gtk_style_detach (GtkStyle *style)
+{
+ g_return_if_fail (GTK_IS_STYLE (style));
+}
+
+/**
+ * gtk_style_lookup_icon_set:
+ * @style: a #GtkStyle
+ * @stock_id: an icon name
+ *
+ * Looks up @stock_id in the icon factories associated with @style
+ * and the default icon factory, returning an icon set if found,
+ * otherwise %NULL.
+ *
+ * Return value: (transfer none): icon set of @stock_id
+ *
+ * Deprecated:3.0: Use gtk_style_context_lookup_icon_set() instead
+ */
+GtkIconSet*
+gtk_style_lookup_icon_set (GtkStyle *style,
+ const char *stock_id)
+{
+ GtkStylePrivate *priv;
+
+ g_return_val_if_fail (GTK_IS_STYLE (style), NULL);
+ g_return_val_if_fail (stock_id != NULL, NULL);
+
+ priv = GTK_STYLE_GET_PRIVATE (style);
+
+ if (priv->context)
+ return gtk_style_context_lookup_icon_set (priv->context, stock_id);
+
+ return gtk_icon_factory_lookup_default (stock_id);
+}
+
+/**
+ * gtk_style_lookup_color:
+ * @style: a #GtkStyle
+ * @color_name: the name of the logical color to look up
+ * @color: (out): the #GdkColor to fill in
+ *
+ * Looks up @color_name in the style's logical color mappings,
+ * filling in @color and returning %TRUE if found, otherwise
+ * returning %FALSE. Do not cache the found mapping, because
+ * it depends on the #GtkStyle and might change when a theme
+ * switch occurs.
+ *
+ * Return value: %TRUE if the mapping was found.
+ *
+ * Since: 2.10
+ *
+ * Deprecated:3.0: Use gtk_style_context_lookup_color() instead
+ **/
+gboolean
+gtk_style_lookup_color (GtkStyle *style,
+ const char *color_name,
+ GdkColor *color)
+{
+ GtkStylePrivate *priv;
+ gboolean result;
+ GdkRGBA rgba;
+
+ g_return_val_if_fail (GTK_IS_STYLE (style), FALSE);
+ g_return_val_if_fail (color_name != NULL, FALSE);
+ g_return_val_if_fail (color != NULL, FALSE);
+
+ priv = GTK_STYLE_GET_PRIVATE (style);
+
+ if (!priv->context)
+ return FALSE;
+
+ result = gtk_style_context_lookup_color (priv->context, color_name, &rgba);
+
+ if (color)
+ {
+ color->red = (guint16) (rgba.red * 65535);
+ color->green = (guint16) (rgba.green * 65535);
+ color->blue = (guint16) (rgba.blue * 65535);
+ color->pixel = 0;
+ }
+
+ return result;
+}
+
+/**
+ * gtk_style_set_background:
+ * @style: a #GtkStyle
+ * @window: a #GdkWindow
+ * @state_type: a state
+ *
+ * Sets the background of @window to the background color or pixmap
+ * specified by @style for the given state.
+ *
+ * Deprecated:3.0: Use gtk_style_context_set_background() instead
+ */
+void
+gtk_style_set_background (GtkStyle *style,
+ GdkWindow *window,
+ GtkStateType state_type)
+{
+ g_return_if_fail (GTK_IS_STYLE (style));
+ g_return_if_fail (window != NULL);
+
+ GTK_STYLE_GET_CLASS (style)->set_background (style, window, state_type);
+}
+
+/* Default functions */
+static GtkStyle *
+gtk_style_real_clone (GtkStyle *style)
+{
+ GtkStylePrivate *priv;
+
+ priv = GTK_STYLE_GET_PRIVATE (style);
+
+ return g_object_new (G_OBJECT_TYPE (style),
+ "context", priv->context,
+ NULL);
+}
+
+static void
+gtk_style_real_copy (GtkStyle *style,
+ GtkStyle *src)
+{
+ gint i;
+
+ for (i = 0; i < 5; i++)
+ {
+ style->fg[i] = src->fg[i];
+ style->bg[i] = src->bg[i];
+ style->text[i] = src->text[i];
+ style->base[i] = src->base[i];
+
+ if (style->background[i])
+ cairo_pattern_destroy (style->background[i]),
+ style->background[i] = src->background[i];
+ if (style->background[i])
+ cairo_pattern_reference (style->background[i]);
+ }
+
+ if (style->font_desc)
+ pango_font_description_free (style->font_desc);
+ if (src->font_desc)
+ style->font_desc = pango_font_description_copy (src->font_desc);
+ else
+ style->font_desc = NULL;
+
+ style->xthickness = src->xthickness;
+ style->ythickness = src->ythickness;
+
+ if (style->rc_style)
+ g_object_unref (style->rc_style);
+ style->rc_style = src->rc_style;
+ if (src->rc_style)
+ g_object_ref (src->rc_style);
+
+ g_slist_foreach (style->icon_factories, (GFunc) g_object_unref, NULL);
+ g_slist_free (style->icon_factories);
+ style->icon_factories = g_slist_copy (src->icon_factories);
+ g_slist_foreach (style->icon_factories, (GFunc) g_object_ref, NULL);
+}
+
+static void
+gtk_style_real_init_from_rc (GtkStyle *style,
+ GtkRcStyle *rc_style)
+{
+}
+
+/**
+ * gtk_style_get_style_property:
+ * @style: a #GtkStyle
+ * @widget_type: the #GType of a descendant of #GtkWidget
+ * @property_name: the name of the style property to get
+ * @value: a #GValue where the value of the property being
+ * queried will be stored
+ *
+ * Queries the value of a style property corresponding to a
+ * widget class is in the given style.
+ *
+ * Since: 2.16
+ */
+void
+gtk_style_get_style_property (GtkStyle *style,
+ GType widget_type,
+ const gchar *property_name,
+ GValue *value)
+{
+ GtkStylePrivate *priv;
+ GtkWidgetClass *klass;
+ GParamSpec *pspec;
+ const GValue *peek_value;
+
+ klass = g_type_class_ref (widget_type);
+ pspec = gtk_widget_class_find_style_property (klass, property_name);
+ g_type_class_unref (klass);
+
+ if (!pspec)
+ {
+ g_warning ("%s: widget class `%s' has no property named `%s'",
+ G_STRLOC,
+ g_type_name (widget_type),
+ property_name);
+ return;
+ }
+
+ priv = GTK_STYLE_GET_PRIVATE (style);
+ peek_value = _gtk_style_context_peek_style_property (priv->context,
+ widget_type,
+ 0, pspec);
+
+ if (G_VALUE_TYPE (value) == G_PARAM_SPEC_VALUE_TYPE (pspec))
+ g_value_copy (peek_value, value);
+ else if (g_value_type_transformable (G_PARAM_SPEC_VALUE_TYPE (pspec), G_VALUE_TYPE (value)))
+ g_value_transform (peek_value, value);
+ else
+ g_warning ("can't retrieve style property `%s' of type `%s' as value of type `%s'",
+ pspec->name,
+ g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)),
+ G_VALUE_TYPE_NAME (value));
+}
+
+/**
+ * gtk_style_get_valist:
+ * @style: a #GtkStyle
+ * @widget_type: the #GType of a descendant of #GtkWidget
+ * @first_property_name: the name of the first style property to get
+ * @var_args: a <type>va_list</type> of pairs of property names and
+ * locations to return the property values, starting with the
+ * location for @first_property_name.
+ *
+ * Non-vararg variant of gtk_style_get().
+ * Used primarily by language bindings.
+ *
+ * Since: 2.16
+ */
+void
+gtk_style_get_valist (GtkStyle *style,
+ GType widget_type,
+ const gchar *first_property_name,
+ va_list var_args)
+{
+ GtkStylePrivate *priv;
+ const char *property_name;
+ GtkWidgetClass *klass;
+
+ g_return_if_fail (GTK_IS_STYLE (style));
+
+ klass = g_type_class_ref (widget_type);
+
+ priv = GTK_STYLE_GET_PRIVATE (style);
+ property_name = first_property_name;
+ while (property_name)
+ {
+ GParamSpec *pspec;
+ const GValue *peek_value;
+ gchar *error;
+
+ pspec = gtk_widget_class_find_style_property (klass, property_name);
+
+ if (!pspec)
+ {
+ g_warning ("%s: widget class `%s' has no property named `%s'",
+ G_STRLOC,
+ g_type_name (widget_type),
+ property_name);
+ break;
+ }
+
+ peek_value = _gtk_style_context_peek_style_property (priv->context, widget_type,
+ 0, pspec);
+ G_VALUE_LCOPY (peek_value, var_args, 0, &error);
+ if (error)
+ {
+ g_warning ("%s: %s", G_STRLOC, error);
+ g_free (error);
+ break;
+ }
+
+ property_name = va_arg (var_args, gchar*);
+ }
+
+ g_type_class_unref (klass);
+}
+
+/**
+ * gtk_style_get:
+ * @style: a #GtkStyle
+ * @widget_type: the #GType of a descendant of #GtkWidget
+ * @first_property_name: the name of the first style property to get
+ * @...: pairs of property names and locations to
+ * return the property values, starting with the location for
+ * @first_property_name, terminated by %NULL.
+ *
+ * Gets the values of a multiple style properties for @widget_type
+ * from @style.
+ *
+ * Since: 2.16
+ */
+void
+gtk_style_get (GtkStyle *style,
+ GType widget_type,
+ const gchar *first_property_name,
+ ...)
+{
+ va_list var_args;
+
+ va_start (var_args, first_property_name);
+ gtk_style_get_valist (style, widget_type, first_property_name, var_args);
+ va_end (var_args);
+}
+
+static void
+gtk_style_real_realize (GtkStyle *style)
+{
+}
+
+static void
+gtk_style_real_unrealize (GtkStyle *style)
+{
+}
+
+static void
+gtk_style_real_set_background (GtkStyle *style,
+ GdkWindow *window,
+ GtkStateType state_type)
+{
+ gdk_window_set_background_pattern (window, style->background[state_type]);
+}
+
+/**
+ * gtk_style_render_icon:
+ * @style: a #GtkStyle
+ * @source: the #GtkIconSource specifying the icon to render
+ * @direction: a text direction
+ * @state: a state
+ * @size: (type int): the size to render the icon at. A size of
+ * (GtkIconSize)-1 means render at the size of the source and
+ * don't scale.
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ *
+ * Renders the icon specified by @source at the given @size
+ * according to the given parameters and returns the result in a
+ * pixbuf.
+ *
+ * Return value: (transfer full): a newly-created #GdkPixbuf
+ * containing the rendered icon
+ *
+ * Deprecated:3.0: Use gtk_render_icon_pixbuf() instead
+ */
+GdkPixbuf *
+gtk_style_render_icon (GtkStyle *style,
+ const GtkIconSource *source,
+ GtkTextDirection direction,
+ GtkStateType state,
+ GtkIconSize size,
+ GtkWidget *widget,
+ const gchar *detail)
+{
+ GdkPixbuf *pixbuf;
+
+ g_return_val_if_fail (GTK_IS_STYLE (style), NULL);
+ g_return_val_if_fail (GTK_STYLE_GET_CLASS (style)->render_icon != NULL, NULL);
+
+ pixbuf = GTK_STYLE_GET_CLASS (style)->render_icon (style, source, direction, state,
+ size, widget, detail);
+
+ g_return_val_if_fail (pixbuf != NULL, NULL);
+
+ return pixbuf;
+}
+
+/* Default functions */
+
+/**
+ * gtk_style_apply_default_background:
+ * @style:
+ * @cr:
+ * @window:
+ * @state_type:
+ * @x:
+ * @y:
+ * @width:
+ * @height:
+ *
+ * Deprecated:3.0: Use #GtkStyleContext instead
+ */
+void
+gtk_style_apply_default_background (GtkStyle *style,
+ cairo_t *cr,
+ GdkWindow *window,
+ GtkStateType state_type,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ cairo_save (cr);
+
+ if (style->background[state_type] == NULL)
+ {
+ GdkWindow *parent = gdk_window_get_parent (window);
+ int x_offset, y_offset;
+
+ if (parent)
+ {
+ gdk_window_get_position (window, &x_offset, &y_offset);
+ cairo_translate (cr, -x_offset, -y_offset);
+ gtk_style_apply_default_background (style, cr,
+ parent, state_type,
+ x + x_offset, y + y_offset,
+ width, height);
+ goto out;
+ }
+ else
+ gdk_cairo_set_source_color (cr, &style->bg[state_type]);
+ }
+ else
+ cairo_set_source (cr, style->background[state_type]);
+
+ cairo_rectangle (cr, x, y, width, height);
+ cairo_fill (cr);
+
+out:
+ cairo_restore (cr);
+}
+
+static GdkPixbuf *
+gtk_default_render_icon (GtkStyle *style,
+ const GtkIconSource *source,
+ GtkTextDirection direction,
+ GtkStateType state,
+ GtkIconSize size,
+ GtkWidget *widget,
+ const gchar *detail)
+{
+ GtkStyleContext *context;
+ GtkStylePrivate *priv;
+ GtkStateFlags flags = 0;
+ GdkPixbuf *pixbuf;
+
+ if (widget)
+ context = gtk_widget_get_style_context (widget);
+ else
+ {
+ priv = GTK_STYLE_GET_PRIVATE (style);
+ context = priv->context;
+ }
+
+ if (!context)
+ return NULL;
+
+ gtk_style_context_save (context);
+
+ if (detail)
+ transform_detail_string (detail, context);
+
+ switch (state)
+ {
+ case GTK_STATE_PRELIGHT:
+ flags |= GTK_STATE_FLAG_PRELIGHT;
+ break;
+ case GTK_STATE_INSENSITIVE:
+ flags |= GTK_STATE_FLAG_INSENSITIVE;
+ break;
+ default:
+ break;
+ }
+
+ gtk_style_context_set_state (context, flags);
+
+ pixbuf = gtk_render_icon_pixbuf (context, source, size);
+
+ gtk_style_context_restore (context);
+
+ return pixbuf;
+}
+
+static void
+_cairo_draw_line (cairo_t *cr,
+ GdkColor *color,
+ gint x1,
+ gint y1,
+ gint x2,
+ gint y2)
+{
+ cairo_save (cr);
+
+ gdk_cairo_set_source_color (cr, color);
+ cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
+
+ cairo_move_to (cr, x1 + 0.5, y1 + 0.5);
+ cairo_line_to (cr, x2 + 0.5, y2 + 0.5);
+ cairo_stroke (cr);
+
+ cairo_restore (cr);
+}
+
+static void
+transform_detail_string (const gchar *detail,
+ GtkStyleContext *context)
+{
+ if (!detail)
+ return;
+
+ if (strcmp (detail, "arrow") == 0)
+ gtk_style_context_add_class (context, "arrow");
+ else if (strcmp (detail, "button") == 0)
+ gtk_style_context_add_class (context, "button");
+ else if (strcmp (detail, "buttondefault") == 0)
+ {
+ gtk_style_context_add_class (context, "button");
+ gtk_style_context_add_class (context, "default");
+ }
+ else if (strcmp (detail, "calendar") == 0)
+ gtk_style_context_add_class (context, "calendar");
+ else if (strcmp (detail, "cellcheck") == 0)
+ {
+ gtk_style_context_add_class (context, "cell");
+ gtk_style_context_add_class (context, "check");
+ }
+ else if (strcmp (detail, "cellradio") == 0)
+ {
+ gtk_style_context_add_class (context, "cell");
+ gtk_style_context_add_class (context, "radio");
+ }
+ else if (strcmp (detail, "checkbutton") == 0)
+ gtk_style_context_add_class (context, "check");
+ else if (strcmp (detail, "check") == 0)
+ {
+ gtk_style_context_add_class (context, "check");
+ gtk_style_context_add_class (context, "menu");
+ }
+ else if (strcmp (detail, "radiobutton") == 0)
+ {
+ gtk_style_context_add_class (context, "radio");
+ }
+ else if (strcmp (detail, "option") == 0)
+ {
+ gtk_style_context_add_class (context, "radio");
+ gtk_style_context_add_class (context, "menu");
+ }
+ else if (strcmp (detail, "entry") == 0 ||
+ strcmp (detail, "entry_bg") == 0)
+ gtk_style_context_add_class (context, "entry");
+ else if (strcmp (detail, "expander") == 0)
+ gtk_style_context_add_class (context, "expander");
+ else if (strcmp (detail, "tooltip") == 0)
+ gtk_style_context_add_class (context, "tooltip");
+ else if (strcmp (detail, "frame") == 0)
+ gtk_style_context_add_class (context, "frame");
+ else if (strcmp (detail, "scrolled_window") == 0)
+ gtk_style_context_add_class (context, "scrolled-window");
+ else if (strcmp (detail, "viewport") == 0 ||
+ strcmp (detail, "viewportbin") == 0)
+ gtk_style_context_add_class (context, "viewport");
+ else if (strncmp (detail, "trough", 6) == 0)
+ gtk_style_context_add_class (context, "trough");
+ else if (strcmp (detail, "spinbutton") == 0)
+ gtk_style_context_add_class (context, "spinbutton");
+ else if (strcmp (detail, "spinbutton_up") == 0)
+ {
+ gtk_style_context_add_class (context, "spinbutton");
+ gtk_style_context_add_class (context, "button");
+ gtk_style_context_set_junction_sides (context, GTK_JUNCTION_BOTTOM);
+ }
+ else if (strcmp (detail, "spinbutton_down") == 0)
+ {
+ gtk_style_context_add_class (context, "spinbutton");
+ gtk_style_context_add_class (context, "button");
+ gtk_style_context_set_junction_sides (context, GTK_JUNCTION_TOP);
+ }
+ else if ((detail[0] == 'h' || detail[0] == 'v') &&
+ strncmp (&detail[1], "scrollbar_", 10) == 0)
+ {
+ gtk_style_context_add_class (context, "button");
+ gtk_style_context_add_class (context, "scrollbar");
+ }
+ else if (strcmp (detail, "slider") == 0)
+ {
+ gtk_style_context_add_class (context, "slider");
+ gtk_style_context_add_class (context, "scrollbar");
+ }
+ else if (strcmp (detail, "vscale") == 0 ||
+ strcmp (detail, "hscale") == 0)
+ {
+ gtk_style_context_add_class (context, "slider");
+ gtk_style_context_add_class (context, "scale");
+ }
+ else if (strcmp (detail, "menuitem") == 0)
+ {
+ gtk_style_context_add_class (context, "menuitem");
+ gtk_style_context_add_class (context, "menu");
+ }
+ else if (strcmp (detail, "menu") == 0)
+ {
+ gtk_style_context_add_class (context, "popup");
+ gtk_style_context_add_class (context, "menu");
+ }
+ else if (strcmp (detail, "accellabel") == 0)
+ gtk_style_context_add_class (context, "accelerator");
+ else if (strcmp (detail, "menubar") == 0)
+ gtk_style_context_add_class (context, "menubar");
+ else if (strcmp (detail, "base") == 0)
+ gtk_style_context_add_class (context, "background");
+ else if (strcmp (detail, "bar") == 0 ||
+ strcmp (detail, "progressbar") == 0)
+ gtk_style_context_add_class (context, "progressbar");
+ else if (strcmp (detail, "toolbar") == 0)
+ gtk_style_context_add_class (context, "toolbar");
+ else if (strcmp (detail, "handlebox_bin") == 0)
+ gtk_style_context_add_class (context, "dock");
+ else if (strcmp (detail, "notebook") == 0)
+ gtk_style_context_add_class (context, "notebook");
+ else if (strcmp (detail, "tab") == 0)
+ {
+ gtk_style_context_add_class (context, "notebook");
+ gtk_style_context_add_region (context, GTK_STYLE_REGION_TAB, 0);
+ }
+ else if (g_str_has_prefix (detail, "cell"))
+ {
+ GtkRegionFlags row, col;
+ gboolean ruled = FALSE;
+ GStrv tokens;
+ guint i;
+
+ tokens = g_strsplit (detail, "_", -1);
+ row = col = 0;
+ i = 0;
+
+ while (tokens[i])
+ {
+ if (strcmp (tokens[i], "even") == 0)
+ row |= GTK_REGION_EVEN;
+ else if (strcmp (tokens[i], "odd") == 0)
+ row |= GTK_REGION_ODD;
+ else if (strcmp (tokens[i], "start") == 0)
+ col |= GTK_REGION_FIRST;
+ else if (strcmp (tokens[i], "end") == 0)
+ col |= GTK_REGION_LAST;
+ else if (strcmp (tokens[i], "ruled") == 0)
+ ruled = TRUE;
+ else if (strcmp (tokens[i], "sorted") == 0)
+ col |= GTK_REGION_SORTED;
+
+ i++;
+ }
+
+ if (!ruled)
+ row &= ~(GTK_REGION_EVEN | GTK_REGION_ODD);
+
+ gtk_style_context_add_class (context, "cell");
+ gtk_style_context_add_region (context, "row", row);
+ gtk_style_context_add_region (context, "column", col);
+
+ g_strfreev (tokens);
+ }
+}
+
+static void
+gtk_default_draw_hline (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x1,
+ gint x2,
+ gint y)
+{
+ GtkStyleContext *context;
+ GtkStylePrivate *priv;
+
+ if (widget)
+ context = gtk_widget_get_style_context (widget);
+ else
+ {
+ priv = GTK_STYLE_GET_PRIVATE (style);
+ context = priv->context;
+ }
+
+ gtk_style_context_save (context);
+
+ if (detail)
+ transform_detail_string (detail, context);
+
+ cairo_save (cr);
+
+ gtk_render_line (context, cr,
+ x1, y, x2, y);
+
+ cairo_restore (cr);
+
+ gtk_style_context_restore (context);
+}
+
+
+static void
+gtk_default_draw_vline (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint y1,
+ gint y2,
+ gint x)
+{
+ GtkStyleContext *context;
+ GtkStylePrivate *priv;
+
+ if (widget)
+ context = gtk_widget_get_style_context (widget);
+ else
+ {
+ priv = GTK_STYLE_GET_PRIVATE (style);
+ context = priv->context;
+ }
+
+ gtk_style_context_save (context);
+
+ if (detail)
+ transform_detail_string (detail, context);
+
+ cairo_save (cr);
+
+ gtk_render_line (context, cr,
+ x, y1, x, y2);
+
+ cairo_restore (cr);
+ gtk_style_context_restore (context);
+}
+
+static void
+gtk_default_draw_shadow (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ GtkStyleContext *context;
+ GtkStylePrivate *priv;
+
+ if (shadow_type == GTK_SHADOW_NONE)
+ return;
+
+ if (widget)
+ context = gtk_widget_get_style_context (widget);
+ else
+ {
+ priv = GTK_STYLE_GET_PRIVATE (style);
+ context = priv->context;
+ }
+
+ gtk_style_context_save (context);
+
+ if (detail)
+ transform_detail_string (detail, context);
+
+ cairo_save (cr);
+
+ gtk_render_frame (context, cr,
+ (gdouble) x,
+ (gdouble) y,
+ (gdouble) width,
+ (gdouble) height);
+
+ cairo_restore (cr);
+ gtk_style_context_restore (context);
+}
+
+static void
+draw_arrow (cairo_t *cr,
+ GdkColor *color,
+ GtkArrowType arrow_type,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ gdk_cairo_set_source_color (cr, color);
+ cairo_save (cr);
+
+ if (arrow_type == GTK_ARROW_DOWN)
+ {
+ cairo_move_to (cr, x, y);
+ cairo_line_to (cr, x + width, y);
+ cairo_line_to (cr, x + width / 2., y + height);
+ }
+ else if (arrow_type == GTK_ARROW_UP)
+ {
+ cairo_move_to (cr, x, y + height);
+ cairo_line_to (cr, x + width / 2., y);
+ cairo_line_to (cr, x + width, y + height);
+ }
+ else if (arrow_type == GTK_ARROW_LEFT)
+ {
+ cairo_move_to (cr, x + width, y);
+ cairo_line_to (cr, x + width, y + height);
+ cairo_line_to (cr, x, y + height / 2.);
+ }
+ else if (arrow_type == GTK_ARROW_RIGHT)
+ {
+ cairo_move_to (cr, x, y);
+ cairo_line_to (cr, x + width, y + height / 2.);
+ cairo_line_to (cr, x, y + height);
+ }
+
+ cairo_close_path (cr);
+ cairo_fill (cr);
+
+ cairo_restore (cr);
+}
+
+static void
+gtk_default_draw_arrow (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state,
+ GtkShadowType shadow,
+ GtkWidget *widget,
+ const gchar *detail,
+ GtkArrowType arrow_type,
+ gboolean fill,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ GtkStyleContext *context;
+ GtkStylePrivate *priv;
+ GtkStateFlags flags = 0;
+ gdouble angle, size;
+
+ if (arrow_type == GTK_ARROW_NONE)
+ return;
+
+ if (widget)
+ context = gtk_widget_get_style_context (widget);
+ else
+ {
+ priv = GTK_STYLE_GET_PRIVATE (style);
+ context = priv->context;
+ }
+
+ gtk_style_context_save (context);
+
+ if (detail)
+ transform_detail_string (detail, context);
+
+ switch (arrow_type)
+ {
+ case GTK_ARROW_UP:
+ angle = 0;
+ size = width;
+ break;
+ case GTK_ARROW_RIGHT:
+ angle = G_PI / 2;
+ size = height;
+ break;
+ case GTK_ARROW_DOWN:
+ angle = G_PI;
+ size = width;
+ break;
+ case GTK_ARROW_LEFT:
+ angle = 3 * (G_PI / 2);
+ size = height;
+ break;
+ default:
+ g_assert_not_reached ();
+ }
+
+ switch (state)
+ {
+ case GTK_STATE_PRELIGHT:
+ flags |= GTK_STATE_FLAG_PRELIGHT;
+ break;
+ case GTK_STATE_SELECTED:
+ flags |= GTK_STATE_FLAG_SELECTED;
+ break;
+ case GTK_STATE_INSENSITIVE:
+ flags |= GTK_STATE_FLAG_INSENSITIVE;
+ break;
+ case GTK_STATE_ACTIVE:
+ flags |= GTK_STATE_FLAG_ACTIVE;
+ break;
+ default:
+ break;
+ }
+
+ gtk_style_context_set_state (context, flags);
+
+ cairo_save (cr);
+
+ gtk_render_arrow (context,
+ cr, angle,
+ (gdouble) x,
+ (gdouble) y,
+ size);
+
+ cairo_restore (cr);
+ gtk_style_context_restore (context);
+}
+
+static void
+gtk_default_draw_diamond (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ gint half_width;
+ gint half_height;
+ GdkColor *outer_nw = NULL;
+ GdkColor *outer_ne = NULL;
+ GdkColor *outer_sw = NULL;
+ GdkColor *outer_se = NULL;
+ GdkColor *middle_nw = NULL;
+ GdkColor *middle_ne = NULL;
+ GdkColor *middle_sw = NULL;
+ GdkColor *middle_se = NULL;
+ GdkColor *inner_nw = NULL;
+ GdkColor *inner_ne = NULL;
+ GdkColor *inner_sw = NULL;
+ GdkColor *inner_se = NULL;
+
+ half_width = width / 2;
+ half_height = height / 2;
+
+ switch (shadow_type)
+ {
+ case GTK_SHADOW_IN:
+ inner_sw = inner_se = &style->bg[state_type];
+ middle_sw = middle_se = &style->light[state_type];
+ outer_sw = outer_se = &style->light[state_type];
+ inner_nw = inner_ne = &style->black;
+ middle_nw = middle_ne = &style->dark[state_type];
+ outer_nw = outer_ne = &style->dark[state_type];
+ break;
+
+ case GTK_SHADOW_OUT:
+ inner_sw = inner_se = &style->dark[state_type];
+ middle_sw = middle_se = &style->dark[state_type];
+ outer_sw = outer_se = &style->black;
+ inner_nw = inner_ne = &style->bg[state_type];
+ middle_nw = middle_ne = &style->light[state_type];
+ outer_nw = outer_ne = &style->light[state_type];
+ break;
+
+ case GTK_SHADOW_ETCHED_IN:
+ inner_sw = inner_se = &style->bg[state_type];
+ middle_sw = middle_se = &style->dark[state_type];
+ outer_sw = outer_se = &style->light[state_type];
+ inner_nw = inner_ne = &style->bg[state_type];
+ middle_nw = middle_ne = &style->light[state_type];
+ outer_nw = outer_ne = &style->dark[state_type];
+ break;
+
+ case GTK_SHADOW_ETCHED_OUT:
+ inner_sw = inner_se = &style->bg[state_type];
+ middle_sw = middle_se = &style->light[state_type];
+ outer_sw = outer_se = &style->dark[state_type];
+ inner_nw = inner_ne = &style->bg[state_type];
+ middle_nw = middle_ne = &style->dark[state_type];
+ outer_nw = outer_ne = &style->light[state_type];
+ break;
+
+ default:
+
+ break;
+ }
+
+ if (inner_sw)
+ {
+ _cairo_draw_line (cr, inner_sw,
+ x + 2, y + half_height,
+ x + half_width, y + height - 2);
+ _cairo_draw_line (cr, inner_se,
+ x + half_width, y + height - 2,
+ x + width - 2, y + half_height);
+ _cairo_draw_line (cr, middle_sw,
+ x + 1, y + half_height,
+ x + half_width, y + height - 1);
+ _cairo_draw_line (cr, middle_se,
+ x + half_width, y + height - 1,
+ x + width - 1, y + half_height);
+ _cairo_draw_line (cr, outer_sw,
+ x, y + half_height,
+ x + half_width, y + height);
+ _cairo_draw_line (cr, outer_se,
+ x + half_width, y + height,
+ x + width, y + half_height);
+
+ _cairo_draw_line (cr, inner_nw,
+ x + 2, y + half_height,
+ x + half_width, y + 2);
+ _cairo_draw_line (cr, inner_ne,
+ x + half_width, y + 2,
+ x + width - 2, y + half_height);
+ _cairo_draw_line (cr, middle_nw,
+ x + 1, y + half_height,
+ x + half_width, y + 1);
+ _cairo_draw_line (cr, middle_ne,
+ x + half_width, y + 1,
+ x + width - 1, y + half_height);
+ _cairo_draw_line (cr, outer_nw,
+ x, y + half_height,
+ x + half_width, y);
+ _cairo_draw_line (cr, outer_ne,
+ x + half_width, y,
+ x + width, y + half_height);
+ }
+}
+
+static void
+option_menu_get_props (GtkWidget *widget,
+ GtkRequisition *indicator_size,
+ GtkBorder *indicator_spacing)
+{
+ GtkRequisition *tmp_size = NULL;
+ GtkBorder *tmp_spacing = NULL;
+
+ if (tmp_size)
+ {
+ *indicator_size = *tmp_size;
+ gtk_requisition_free (tmp_size);
+ }
+ else
+ *indicator_size = default_option_indicator_size;
+
+ if (tmp_spacing)
+ {
+ *indicator_spacing = *tmp_spacing;
+ gtk_border_free (tmp_spacing);
+ }
+ else
+ *indicator_spacing = default_option_indicator_spacing;
+}
+
+static void
+gtk_default_draw_box (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ GtkStyleContext *context;
+ GtkStylePrivate *priv;
+ GtkStateFlags flags = 0;
+
+ if (widget)
+ context = gtk_widget_get_style_context (widget);
+ else
+ {
+ priv = GTK_STYLE_GET_PRIVATE (style);
+ context = priv->context;
+ }
+
+ gtk_style_context_save (context);
+
+ if (detail)
+ transform_detail_string (detail, context);
+
+ switch (state_type)
+ {
+ case GTK_STATE_ACTIVE:
+ flags |= GTK_STATE_FLAG_ACTIVE;
+ break;
+ case GTK_STATE_PRELIGHT:
+ flags |= GTK_STATE_FLAG_PRELIGHT;
+ break;
+ case GTK_STATE_SELECTED:
+ flags |= GTK_STATE_FLAG_SELECTED;
+ break;
+ case GTK_STATE_INSENSITIVE:
+ flags |= GTK_STATE_FLAG_INSENSITIVE;
+ break;
+ default:
+ break;
+ }
+
+ if (shadow_type == GTK_SHADOW_IN)
+ flags |= GTK_STATE_FLAG_ACTIVE;
+
+ gtk_style_context_set_state (context, flags);
+
+ cairo_save (cr);
+
+ if (gtk_style_context_has_class (context, GTK_STYLE_CLASS_PROGRESSBAR))
+ gtk_render_activity (context, cr, x, y, width, height);
+ else
+ {
+ gtk_render_background (context, cr, x, y, width, height);
+
+ if (shadow_type != GTK_SHADOW_NONE)
+ gtk_render_frame (context, cr, x, y, width, height);
+ }
+
+ cairo_restore (cr);
+ gtk_style_context_restore (context);
+}
+
+static void
+gtk_default_draw_flat_box (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ GtkStyleContext *context;
+ GtkStylePrivate *priv;
+ GtkStateFlags flags = 0;
+
+ if (widget)
+ context = gtk_widget_get_style_context (widget);
+ else
+ {
+ priv = GTK_STYLE_GET_PRIVATE (style);
+ context = priv->context;
+ }
+
+ gtk_style_context_save (context);
+
+ if (detail)
+ transform_detail_string (detail, context);
+
+ switch (state_type)
+ {
+ case GTK_STATE_PRELIGHT:
+ flags |= GTK_STATE_FLAG_PRELIGHT;
+ break;
+ case GTK_STATE_SELECTED:
+ flags |= GTK_STATE_FLAG_SELECTED;
+ break;
+ case GTK_STATE_INSENSITIVE:
+ flags |= GTK_STATE_FLAG_INSENSITIVE;
+ break;
+ case GTK_STATE_ACTIVE:
+ flags |= GTK_STATE_FLAG_ACTIVE;
+ break;
+ case GTK_STATE_FOCUSED:
+ flags |= GTK_STATE_FLAG_FOCUSED;
+ break;
+ default:
+ break;
+ }
+
+ gtk_style_context_set_state (context, flags);
+
+ cairo_save (cr);
+
+ gtk_render_background (context, cr,
+ (gdouble) x,
+ (gdouble) y,
+ (gdouble) width,
+ (gdouble) height);
+
+ cairo_restore (cr);
+ gtk_style_context_restore (context);
+}
+
+static void
+gtk_default_draw_check (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ GtkStyleContext *context;
+ GtkStylePrivate *priv;
+ GtkStateFlags flags = 0;
+
+ if (widget)
+ context = gtk_widget_get_style_context (widget);
+ else
+ {
+ priv = GTK_STYLE_GET_PRIVATE (style);
+ context = priv->context;
+ }
+
+ gtk_style_context_save (context);
+
+ if (detail)
+ transform_detail_string (detail, context);
+
+ switch (state_type)
+ {
+ case GTK_STATE_PRELIGHT:
+ flags |= GTK_STATE_FLAG_PRELIGHT;
+ break;
+ case GTK_STATE_SELECTED:
+ flags |= GTK_STATE_FLAG_SELECTED;
+ break;
+ case GTK_STATE_INSENSITIVE:
+ flags |= GTK_STATE_FLAG_INSENSITIVE;
+ break;
+ default:
+ break;
+ }
+
+ if (shadow_type == GTK_SHADOW_IN)
+ flags |= GTK_STATE_FLAG_ACTIVE;
+ else if (shadow_type == GTK_SHADOW_ETCHED_IN)
+ flags |= GTK_STATE_FLAG_INCONSISTENT;
+
+ gtk_style_context_set_state (context, flags);
+
+ cairo_save (cr);
+
+ gtk_render_check (context,
+ cr, x, y,
+ width, height);
+
+ cairo_restore (cr);
+ gtk_style_context_restore (context);
+}
+
+static void
+gtk_default_draw_option (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ GtkStyleContext *context;
+ GtkStylePrivate *priv;
+ GtkStateFlags flags = 0;
+
+ if (widget)
+ context = gtk_widget_get_style_context (widget);
+ else
+ {
+ priv = GTK_STYLE_GET_PRIVATE (style);
+ context = priv->context;
+ }
+
+ gtk_style_context_save (context);
+
+ if (detail)
+ transform_detail_string (detail, context);
+
+ switch (state_type)
+ {
+ case GTK_STATE_PRELIGHT:
+ flags |= GTK_STATE_FLAG_PRELIGHT;
+ break;
+ case GTK_STATE_SELECTED:
+ flags |= GTK_STATE_FLAG_SELECTED;
+ break;
+ case GTK_STATE_INSENSITIVE:
+ flags |= GTK_STATE_FLAG_INSENSITIVE;
+ break;
+ default:
+ break;
+ }
+
+ if (shadow_type == GTK_SHADOW_IN)
+ flags |= GTK_STATE_FLAG_ACTIVE;
+ else if (shadow_type == GTK_SHADOW_ETCHED_IN)
+ flags |= GTK_STATE_FLAG_INCONSISTENT;
+
+ gtk_style_context_set_state (context, flags);
+
+ cairo_save (cr);
+ gtk_render_option (context, cr,
+ (gdouble) x,
+ (gdouble) y,
+ (gdouble) width,
+ (gdouble) height);
+
+ cairo_restore (cr);
+ gtk_style_context_restore (context);
+}
+
+static void
+gtk_default_draw_tab (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+#define ARROW_SPACE 4
+
+ GtkRequisition indicator_size;
+ GtkBorder indicator_spacing;
+ gint arrow_height;
+
+ option_menu_get_props (widget, &indicator_size, &indicator_spacing);
+
+ indicator_size.width += (indicator_size.width % 2) - 1;
+ arrow_height = indicator_size.width / 2 + 1;
+
+ x += (width - indicator_size.width) / 2;
+ y += (height - (2 * arrow_height + ARROW_SPACE)) / 2;
+
+ if (state_type == GTK_STATE_INSENSITIVE)
+ {
+ draw_arrow (cr, &style->white,
+ GTK_ARROW_UP, x + 1, y + 1,
+ indicator_size.width, arrow_height);
+
+ draw_arrow (cr, &style->white,
+ GTK_ARROW_DOWN, x + 1, y + arrow_height + ARROW_SPACE + 1,
+ indicator_size.width, arrow_height);
+ }
+
+ draw_arrow (cr, &style->fg[state_type],
+ GTK_ARROW_UP, x, y,
+ indicator_size.width, arrow_height);
+
+
+ draw_arrow (cr, &style->fg[state_type],
+ GTK_ARROW_DOWN, x, y + arrow_height + ARROW_SPACE,
+ indicator_size.width, arrow_height);
+}
+
+static void
+gtk_default_draw_shadow_gap (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ GtkPositionType gap_side,
+ gint gap_x,
+ gint gap_width)
+{
+ GtkStyleContext *context;
+ GtkStylePrivate *priv;
+ GtkStateFlags flags = 0;
+
+ if (shadow_type == GTK_SHADOW_NONE)
+ return;
+
+ if (widget)
+ context = gtk_widget_get_style_context (widget);
+ else
+ {
+ priv = GTK_STYLE_GET_PRIVATE (style);
+ context = priv->context;
+ }
+
+ gtk_style_context_save (context);
+
+ if (detail)
+ transform_detail_string (detail, context);
+
+ switch (state_type)
+ {
+ case GTK_STATE_ACTIVE:
+ flags |= GTK_STATE_FLAG_ACTIVE;
+ break;
+ case GTK_STATE_PRELIGHT:
+ flags |= GTK_STATE_FLAG_PRELIGHT;
+ break;
+ case GTK_STATE_SELECTED:
+ flags |= GTK_STATE_FLAG_SELECTED;
+ break;
+ case GTK_STATE_INSENSITIVE:
+ flags |= GTK_STATE_FLAG_INSENSITIVE;
+ break;
+ default:
+ break;
+ }
+
+ gtk_style_context_set_state (context, flags);
+
+ cairo_save (cr);
+ gtk_render_frame_gap (context, cr,
+ (gdouble) x,
+ (gdouble) y,
+ (gdouble) width,
+ (gdouble) height,
+ gap_side,
+ (gdouble) gap_x,
+ (gdouble) gap_x + gap_width);
+
+ cairo_restore (cr);
+ gtk_style_context_restore (context);
+}
+
+static void
+gtk_default_draw_box_gap (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ GtkPositionType gap_side,
+ gint gap_x,
+ gint gap_width)
+{
+ GtkStyleContext *context;
+ GtkStylePrivate *priv;
+ GtkStateFlags flags = 0;
+
+ if (widget)
+ context = gtk_widget_get_style_context (widget);
+ else
+ {
+ priv = GTK_STYLE_GET_PRIVATE (style);
+ context = priv->context;
+ }
+
+ gtk_style_context_save (context);
+
+ if (detail)
+ transform_detail_string (detail, context);
+
+ switch (state_type)
+ {
+ case GTK_STATE_ACTIVE:
+ flags |= GTK_STATE_FLAG_ACTIVE;
+ break;
+ case GTK_STATE_PRELIGHT:
+ flags |= GTK_STATE_FLAG_PRELIGHT;
+ break;
+ case GTK_STATE_SELECTED:
+ flags |= GTK_STATE_FLAG_SELECTED;
+ break;
+ case GTK_STATE_INSENSITIVE:
+ flags |= GTK_STATE_FLAG_INSENSITIVE;
+ break;
+ default:
+ break;
+ }
+
+ gtk_style_context_set_state (context, flags);
+
+ cairo_save (cr);
+ gtk_render_background (context, cr,
+ (gdouble) x,
+ (gdouble) y,
+ (gdouble) width,
+ (gdouble) height);
+
+
+ if (shadow_type != GTK_SHADOW_NONE)
+ gtk_render_frame_gap (context, cr,
+ (gdouble) x,
+ (gdouble) y,
+ (gdouble) width,
+ (gdouble) height,
+ gap_side,
+ (gdouble) gap_x,
+ (gdouble) gap_x + gap_width);
+
+ cairo_restore (cr);
+ gtk_style_context_restore (context);
+}
+
+static void
+gtk_default_draw_extension (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ GtkPositionType gap_side)
+{
+ GtkStyleContext *context;
+ GtkStylePrivate *priv;
+ GtkStateFlags flags = 0;
+
+ if (widget)
+ context = gtk_widget_get_style_context (widget);
+ else
+ {
+ priv = GTK_STYLE_GET_PRIVATE (style);
+ context = priv->context;
+ }
+
+ gtk_style_context_save (context);
+
+ if (detail)
+ transform_detail_string (detail, context);
+
+ switch (state_type)
+ {
+ case GTK_STATE_ACTIVE:
+ flags |= GTK_STATE_FLAG_ACTIVE;
+ break;
+ case GTK_STATE_PRELIGHT:
+ flags |= GTK_STATE_FLAG_PRELIGHT;
+ break;
+ case GTK_STATE_SELECTED:
+ flags |= GTK_STATE_FLAG_SELECTED;
+ break;
+ case GTK_STATE_INSENSITIVE:
+ flags |= GTK_STATE_FLAG_INSENSITIVE;
+ break;
+ default:
+ break;
+ }
+
+ gtk_style_context_set_state (context, flags);
+
+ cairo_save (cr);
+
+ gtk_render_extension (context, cr,
+ (gdouble) x,
+ (gdouble) y,
+ (gdouble) width,
+ (gdouble) height,
+ gap_side);
+
+ cairo_restore (cr);
+ gtk_style_context_restore (context);
+}
+
+static void
+gtk_default_draw_focus (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ GtkStyleContext *context;
+ GtkStylePrivate *priv;
+
+ if (widget)
+ context = gtk_widget_get_style_context (widget);
+ else
+ {
+ priv = GTK_STYLE_GET_PRIVATE (style);
+ context = priv->context;
+ }
+
+ gtk_style_context_save (context);
+
+ if (detail)
+ transform_detail_string (detail, context);
+
+ cairo_save (cr);
+
+ gtk_render_focus (context, cr,
+ (gdouble) x,
+ (gdouble) y,
+ (gdouble) width,
+ (gdouble) height);
+
+ cairo_restore (cr);
+ gtk_style_context_restore (context);
+}
+
+static void
+gtk_default_draw_slider (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ GtkOrientation orientation)
+{
+ GtkStyleContext *context;
+ GtkStylePrivate *priv;
+ GtkStateFlags flags = 0;
+
+ if (widget)
+ context = gtk_widget_get_style_context (widget);
+ else
+ {
+ priv = GTK_STYLE_GET_PRIVATE (style);
+ context = priv->context;
+ }
+
+ gtk_style_context_save (context);
+
+ if (detail)
+ transform_detail_string (detail, context);
+
+ switch (state_type)
+ {
+ case GTK_STATE_PRELIGHT:
+ flags |= GTK_STATE_FLAG_PRELIGHT;
+ break;
+ case GTK_STATE_SELECTED:
+ flags |= GTK_STATE_FLAG_SELECTED;
+ break;
+ case GTK_STATE_INSENSITIVE:
+ flags |= GTK_STATE_FLAG_INSENSITIVE;
+ break;
+ default:
+ break;
+ }
+
+ gtk_style_context_set_state (context, flags);
+
+ cairo_save (cr);
+
+ gtk_render_slider (context, cr, x, y, width, height, orientation);
+
+ cairo_restore (cr);
+ gtk_style_context_restore (context);
+}
+
+static void
+gtk_default_draw_handle (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ GtkOrientation orientation)
+{
+ GtkStyleContext *context;
+ GtkStylePrivate *priv;
+ GtkStateFlags flags = 0;
+
+ if (widget)
+ context = gtk_widget_get_style_context (widget);
+ else
+ {
+ priv = GTK_STYLE_GET_PRIVATE (style);
+ context = priv->context;
+ }
+
+ gtk_style_context_save (context);
+
+ if (detail)
+ transform_detail_string (detail, context);
+
+ switch (state_type)
+ {
+ case GTK_STATE_PRELIGHT:
+ flags |= GTK_STATE_FLAG_PRELIGHT;
+ break;
+ case GTK_STATE_SELECTED:
+ flags |= GTK_STATE_FLAG_SELECTED;
+ break;
+ case GTK_STATE_INSENSITIVE:
+ flags |= GTK_STATE_FLAG_INSENSITIVE;
+ break;
+ default:
+ break;
+ }
+
+ gtk_style_context_set_state (context, flags);
+
+ cairo_save (cr);
+
+ gtk_render_handle (context, cr,
+ (gdouble) x,
+ (gdouble) y,
+ (gdouble) width,
+ (gdouble) height);
+
+ cairo_restore (cr);
+ gtk_style_context_restore (context);
+}
+
+static void
+gtk_default_draw_expander (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ GtkExpanderStyle expander_style)
+{
+ GtkStyleContext *context;
+ GtkStylePrivate *priv;
+ GtkStateFlags flags = 0;
+ gint size;
+
+ if (widget)
+ context = gtk_widget_get_style_context (widget);
+ else
+ {
+ priv = GTK_STYLE_GET_PRIVATE (style);
+ context = priv->context;
+ }
+
+ gtk_style_context_save (context);
+
+ if (detail)
+ transform_detail_string (detail, context);
+
+ gtk_style_context_add_class (context, "expander");
+
+ switch (state_type)
+ {
+ case GTK_STATE_PRELIGHT:
+ flags |= GTK_STATE_FLAG_PRELIGHT;
+ break;
+ case GTK_STATE_SELECTED:
+ flags |= GTK_STATE_FLAG_SELECTED;
+ break;
+ case GTK_STATE_INSENSITIVE:
+ flags |= GTK_STATE_FLAG_INSENSITIVE;
+ break;
+ default:
+ break;
+ }
+
+ if (widget &&
+ gtk_widget_class_find_style_property (GTK_WIDGET_GET_CLASS (widget),
+ "expander-size"))
+ gtk_widget_style_get (widget, "expander-size", &size, NULL);
+ else
+ size = 12;
+
+ if (expander_style == GTK_EXPANDER_EXPANDED)
+ flags |= GTK_STATE_FLAG_ACTIVE;
+
+ gtk_style_context_set_state (context, flags);
+
+ cairo_save (cr);
+
+ gtk_render_expander (context, cr,
+ (gdouble) x - (size / 2),
+ (gdouble) y - (size / 2),
+ (gdouble) size,
+ (gdouble) size);
+
+ cairo_restore (cr);
+ gtk_style_context_restore (context);
+}
+
+static void
+gtk_default_draw_layout (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ gboolean use_text,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ PangoLayout *layout)
+{
+ GtkStyleContext *context;
+ GtkStylePrivate *priv;
+ GtkStateFlags flags = 0;
+
+ if (widget)
+ context = gtk_widget_get_style_context (widget);
+ else
+ {
+ priv = GTK_STYLE_GET_PRIVATE (style);
+ context = priv->context;
+ }
+
+ gtk_style_context_save (context);
+
+ if (detail)
+ transform_detail_string (detail, context);
+
+ switch (state_type)
+ {
+ case GTK_STATE_PRELIGHT:
+ flags |= GTK_STATE_FLAG_PRELIGHT;
+ break;
+ case GTK_STATE_SELECTED:
+ flags |= GTK_STATE_FLAG_SELECTED;
+ break;
+ case GTK_STATE_INSENSITIVE:
+ flags |= GTK_STATE_FLAG_INSENSITIVE;
+ break;
+ default:
+ break;
+ }
+
+ gtk_style_context_set_state (context, flags);
+
+ cairo_save (cr);
+
+ gtk_render_layout (context, cr,
+ (gdouble) x,
+ (gdouble) y,
+ layout);
+
+ cairo_restore (cr);
+ gtk_style_context_restore (context);
+}
+
+static void
+gtk_default_draw_resize_grip (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ GdkWindowEdge edge,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ GtkStyleContext *context;
+ GtkStylePrivate *priv;
+ GtkStateFlags flags = 0;
+ GtkJunctionSides sides = 0;
+
+ if (widget)
+ context = gtk_widget_get_style_context (widget);
+ else
+ {
+ priv = GTK_STYLE_GET_PRIVATE (style);
+ context = priv->context;
+ }
+
+ gtk_style_context_save (context);
+
+ if (detail)
+ transform_detail_string (detail, context);
+
+ gtk_style_context_add_class (context, "grip");
+
+ switch (state_type)
+ {
+ case GTK_STATE_PRELIGHT:
+ flags |= GTK_STATE_FLAG_PRELIGHT;
+ break;
+ case GTK_STATE_SELECTED:
+ flags |= GTK_STATE_FLAG_SELECTED;
+ break;
+ case GTK_STATE_INSENSITIVE:
+ flags |= GTK_STATE_FLAG_INSENSITIVE;
+ break;
+ default:
+ break;
+ }
+
+ gtk_style_context_set_state (context, flags);
+
+ switch (edge)
+ {
+ case GDK_WINDOW_EDGE_NORTH_WEST:
+ sides = GTK_JUNCTION_CORNER_TOPLEFT;
+ break;
+ case GDK_WINDOW_EDGE_NORTH:
+ sides = GTK_JUNCTION_TOP;
+ break;
+ case GDK_WINDOW_EDGE_NORTH_EAST:
+ sides = GTK_JUNCTION_CORNER_TOPRIGHT;
+ break;
+ case GDK_WINDOW_EDGE_WEST:
+ sides = GTK_JUNCTION_LEFT;
+ break;
+ case GDK_WINDOW_EDGE_EAST:
+ sides = GTK_JUNCTION_RIGHT;
+ break;
+ case GDK_WINDOW_EDGE_SOUTH_WEST:
+ sides = GTK_JUNCTION_CORNER_BOTTOMLEFT;
+ break;
+ case GDK_WINDOW_EDGE_SOUTH:
+ sides = GTK_JUNCTION_BOTTOM;
+ break;
+ case GDK_WINDOW_EDGE_SOUTH_EAST:
+ sides = GTK_JUNCTION_CORNER_BOTTOMRIGHT;
+ break;
+ }
+
+ gtk_style_context_set_junction_sides (context, sides);
+
+ cairo_save (cr);
+
+ gtk_render_handle (context, cr,
+ (gdouble) x,
+ (gdouble) y,
+ (gdouble) width,
+ (gdouble) height);
+
+ cairo_restore (cr);
+ gtk_style_context_restore (context);
+}
+
+static void
+gtk_default_draw_spinner (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ guint step,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ GdkColor *color;
+ guint num_steps;
+ gdouble dx, dy;
+ gdouble radius;
+ gdouble half;
+ gint i;
+ guint real_step;
+
+ num_steps = 12;
+ real_step = step % num_steps;
+
+ /* set a clip region for the expose event */
+ cairo_rectangle (cr, x, y, width, height);
+ cairo_clip (cr);
+
+ cairo_translate (cr, x, y);
+
+ /* draw clip region */
+ cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
+
+ color = &style->fg[state_type];
+ dx = width / 2;
+ dy = height / 2;
+ radius = MIN (width / 2, height / 2);
+ half = num_steps / 2;
+
+ for (i = 0; i < num_steps; i++)
+ {
+ gint inset = 0.7 * radius;
+
+ /* transparency is a function of time and intial value */
+ gdouble t = (gdouble) ((i + num_steps - real_step)
+ % num_steps) / num_steps;
+
+ cairo_save (cr);
+
+ cairo_set_source_rgba (cr,
+ color->red / 65535.,
+ color->green / 65535.,
+ color->blue / 65535.,
+ t);
+
+ cairo_set_line_width (cr, 2.0);
+ cairo_move_to (cr,
+ dx + (radius - inset) * cos (i * G_PI / half),
+ dy + (radius - inset) * sin (i * G_PI / half));
+ cairo_line_to (cr,
+ dx + radius * cos (i * G_PI / half),
+ dy + radius * sin (i * G_PI / half));
+ cairo_stroke (cr);
+
+ cairo_restore (cr);
+ }
+}
+
+void
+_gtk_style_shade (const GdkColor *a,
+ GdkColor *b,
+ gdouble k)
+{
+ gdouble red;
+ gdouble green;
+ gdouble blue;
+
+ red = (gdouble) a->red / 65535.0;
+ green = (gdouble) a->green / 65535.0;
+ blue = (gdouble) a->blue / 65535.0;
+
+ rgb_to_hls (&red, &green, &blue);
+
+ green *= k;
+ if (green > 1.0)
+ green = 1.0;
+ else if (green < 0.0)
+ green = 0.0;
+
+ blue *= k;
+ if (blue > 1.0)
+ blue = 1.0;
+ else if (blue < 0.0)
+ blue = 0.0;
+
+ hls_to_rgb (&red, &green, &blue);
+
+ b->red = red * 65535.0;
+ b->green = green * 65535.0;
+ b->blue = blue * 65535.0;
+}
+
+static void
+rgb_to_hls (gdouble *r,
+ gdouble *g,
+ gdouble *b)
+{
+ gdouble min;
+ gdouble max;
+ gdouble red;
+ gdouble green;
+ gdouble blue;
+ gdouble h, l, s;
+ gdouble delta;
+
+ red = *r;
+ green = *g;
+ blue = *b;
+
+ if (red > green)
+ {
+ if (red > blue)
+ max = red;
+ else
+ max = blue;
+
+ if (green < blue)
+ min = green;
+ else
+ min = blue;
+ }
+ else
+ {
+ if (green > blue)
+ max = green;
+ else
+ max = blue;
+
+ if (red < blue)
+ min = red;
+ else
+ min = blue;
+ }
+
+ l = (max + min) / 2;
+ s = 0;
+ h = 0;
+
+ if (max != min)
+ {
+ if (l <= 0.5)
+ s = (max - min) / (max + min);
+ else
+ s = (max - min) / (2 - max - min);
+
+ delta = max -min;
+ if (red == max)
+ h = (green - blue) / delta;
+ else if (green == max)
+ h = 2 + (blue - red) / delta;
+ else if (blue == max)
+ h = 4 + (red - green) / delta;
+
+ h *= 60;
+ if (h < 0.0)
+ h += 360;
+ }
+
+ *r = h;
+ *g = l;
+ *b = s;
+}
+
+static void
+hls_to_rgb (gdouble *h,
+ gdouble *l,
+ gdouble *s)
+{
+ gdouble hue;
+ gdouble lightness;
+ gdouble saturation;
+ gdouble m1, m2;
+ gdouble r, g, b;
+
+ lightness = *l;
+ saturation = *s;
+
+ if (lightness <= 0.5)
+ m2 = lightness * (1 + saturation);
+ else
+ m2 = lightness + saturation - lightness * saturation;
+ m1 = 2 * lightness - m2;
+
+ if (saturation == 0)
+ {
+ *h = lightness;
+ *l = lightness;
+ *s = lightness;
+ }
+ else
+ {
+ hue = *h + 120;
+ while (hue > 360)
+ hue -= 360;
+ while (hue < 0)
+ hue += 360;
+
+ if (hue < 60)
+ r = m1 + (m2 - m1) * hue / 60;
+ else if (hue < 180)
+ r = m2;
+ else if (hue < 240)
+ r = m1 + (m2 - m1) * (240 - hue) / 60;
+ else
+ r = m1;
+
+ hue = *h;
+ while (hue > 360)
+ hue -= 360;
+ while (hue < 0)
+ hue += 360;
+
+ if (hue < 60)
+ g = m1 + (m2 - m1) * hue / 60;
+ else if (hue < 180)
+ g = m2;
+ else if (hue < 240)
+ g = m1 + (m2 - m1) * (240 - hue) / 60;
+ else
+ g = m1;
+
+ hue = *h - 120;
+ while (hue > 360)
+ hue -= 360;
+ while (hue < 0)
+ hue += 360;
+
+ if (hue < 60)
+ b = m1 + (m2 - m1) * hue / 60;
+ else if (hue < 180)
+ b = m2;
+ else if (hue < 240)
+ b = m1 + (m2 - m1) * (240 - hue) / 60;
+ else
+ b = m1;
+
+ *h = r;
+ *l = g;
+ *s = b;
+ }
+}
+
+
+/**
+ * gtk_paint_hline:
+ * @style: a #GtkStyle
+ * @cr: a #caio_t
+ * @state_type: a state
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @x1: the starting x coordinate
+ * @x2: the ending x coordinate
+ * @y: the y coordinate
+ *
+ * Draws a horizontal line from (@x1, @y) to (@x2, @y) in @cr
+ * using the given style and state.
+ *
+ * Deprecated:3.0: Use gtk_render_line() instead
+ **/
+void
+gtk_paint_hline (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x1,
+ gint x2,
+ gint y)
+{
+ g_return_if_fail (GTK_IS_STYLE (style));
+ g_return_if_fail (cr != NULL);
+ g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_hline != NULL);
+
+ cairo_save (cr);
+
+ GTK_STYLE_GET_CLASS (style)->draw_hline (style, cr, state_type,
+ widget, detail,
+ x1, x2, y);
+
+ cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_vline:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @y1_: the starting y coordinate
+ * @y2_: the ending y coordinate
+ * @x: the x coordinate
+ *
+ * Draws a vertical line from (@x, @y1_) to (@x, @y2_) in @cr
+ * using the given style and state.
+ *
+ * Deprecated:3.0: Use gtk_render_line() instead
+ */
+void
+gtk_paint_vline (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint y1_,
+ gint y2_,
+ gint x)
+{
+ g_return_if_fail (GTK_IS_STYLE (style));
+ g_return_if_fail (cr != NULL);
+ g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_vline != NULL);
+
+ cairo_save (cr);
+
+ GTK_STYLE_GET_CLASS (style)->draw_vline (style, cr, state_type,
+ widget, detail,
+ y1_, y2_, x);
+
+ cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_shadow:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @shadow_type: type of shadow to draw
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @x: x origin of the rectangle
+ * @y: y origin of the rectangle
+ * @width: width of the rectangle
+ * @height: width of the rectangle
+ *
+ * Draws a shadow around the given rectangle in @cr
+ * using the given style and state and shadow type.
+ *
+ * Deprecated:3.0: Use gtk_render_frame() instead
+ */
+void
+gtk_paint_shadow (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ g_return_if_fail (GTK_IS_STYLE (style));
+ g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_shadow != NULL);
+ g_return_if_fail (cr != NULL);
+ g_return_if_fail (width >= 0);
+ g_return_if_fail (height >= 0);
+
+ cairo_save (cr);
+
+ GTK_STYLE_GET_CLASS (style)->draw_shadow (style, cr, state_type, shadow_type,
+ widget, detail,
+ x, y, width, height);
+
+ cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_arrow:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @shadow_type: the type of shadow to draw
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @arrow_type: the type of arrow to draw
+ * @fill: %TRUE if the arrow tip should be filled
+ * @x: x origin of the rectangle to draw the arrow in
+ * @y: y origin of the rectangle to draw the arrow in
+ * @width: width of the rectangle to draw the arrow in
+ * @height: height of the rectangle to draw the arrow in
+ *
+ * Draws an arrow in the given rectangle on @cr using the given
+ * parameters. @arrow_type determines the direction of the arrow.
+ *
+ * Deprecated:3.0: Use gtk_render_arrow() instead
+ */
+void
+gtk_paint_arrow (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ GtkArrowType arrow_type,
+ gboolean fill,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ g_return_if_fail (GTK_IS_STYLE (style));
+ g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_arrow != NULL);
+ g_return_if_fail (cr != NULL);
+ g_return_if_fail (width >= 0);
+ g_return_if_fail (height >= 0);
+
+ cairo_save (cr);
+
+ GTK_STYLE_GET_CLASS (style)->draw_arrow (style, cr, state_type, shadow_type,
+ widget, detail,
+ arrow_type, fill, x, y, width, height);
+
+ cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_diamond:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @shadow_type: the type of shadow to draw
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @x: x origin of the rectangle to draw the diamond in
+ * @y: y origin of the rectangle to draw the diamond in
+ * @width: width of the rectangle to draw the diamond in
+ * @height: height of the rectangle to draw the diamond in
+ *
+ * Draws a diamond in the given rectangle on @window using the given
+ * parameters.
+ *
+ * Deprecated:3.0: Use cairo instead
+ */
+void
+gtk_paint_diamond (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ g_return_if_fail (GTK_IS_STYLE (style));
+ g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_diamond != NULL);
+ g_return_if_fail (cr != NULL);
+ g_return_if_fail (width >= 0);
+ g_return_if_fail (height >= 0);
+
+ cairo_save (cr);
+
+ GTK_STYLE_GET_CLASS (style)->draw_diamond (style, cr, state_type, shadow_type,
+ widget, detail,
+ x, y, width, height);
+
+ cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_box:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @shadow_type: the type of shadow to draw
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @x: x origin of the box
+ * @y: y origin of the box
+ * @width: the width of the box
+ * @height: the height of the box
+ *
+ * Draws a box on @cr with the given parameters.
+ *
+ * Deprecated:3.0: Use gtk_render_frame() and gtk_render_background() instead
+ */
+void
+gtk_paint_box (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ g_return_if_fail (GTK_IS_STYLE (style));
+ g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_box != NULL);
+ g_return_if_fail (cr != NULL);
+
+ cairo_save (cr);
+
+ GTK_STYLE_GET_CLASS (style)->draw_box (style, cr, state_type, shadow_type,
+ widget, detail,
+ x, y, width, height);
+
+ cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_flat_box:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @shadow_type: the type of shadow to draw
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @x: x origin of the box
+ * @y: y origin of the box
+ * @width: the width of the box
+ * @height: the height of the box
+ *
+ * Draws a flat box on @cr with the given parameters.
+ *
+ * Deprecated:3.0: Use gtk_render_frame() and gtk_render_background() instead
+ */
+void
+gtk_paint_flat_box (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ g_return_if_fail (GTK_IS_STYLE (style));
+ g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_flat_box != NULL);
+ g_return_if_fail (cr != NULL);
+ g_return_if_fail (width >= 0);
+ g_return_if_fail (height >= 0);
+
+ cairo_save (cr);
+
+ GTK_STYLE_GET_CLASS (style)->draw_flat_box (style, cr, state_type, shadow_type,
+ widget, detail,
+ x, y, width, height);
+
+ cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_check:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @shadow_type: the type of shadow to draw
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @x: x origin of the rectangle to draw the check in
+ * @y: y origin of the rectangle to draw the check in
+ * @width: the width of the rectangle to draw the check in
+ * @height: the height of the rectangle to draw the check in
+ *
+ * Draws a check button indicator in the given rectangle on @cr with
+ * the given parameters.
+ *
+ * Deprecated:3.0: Use gtk_render_check() instead
+ */
+void
+gtk_paint_check (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ g_return_if_fail (GTK_IS_STYLE (style));
+ g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_check != NULL);
+ g_return_if_fail (cr != NULL);
+
+ cairo_save (cr);
+
+ GTK_STYLE_GET_CLASS (style)->draw_check (style, cr, state_type, shadow_type,
+ widget, detail,
+ x, y, width, height);
+
+ cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_option:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @shadow_type: the type of shadow to draw
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @x: x origin of the rectangle to draw the option in
+ * @y: y origin of the rectangle to draw the option in
+ * @width: the width of the rectangle to draw the option in
+ * @height: the height of the rectangle to draw the option in
+ *
+ * Draws a radio button indicator in the given rectangle on @cr with
+ * the given parameters.
+ *
+ * Deprecated:3.0: Use gtk_render_option() instead
+ */
+void
+gtk_paint_option (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ g_return_if_fail (GTK_IS_STYLE (style));
+ g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_option != NULL);
+ g_return_if_fail (cr != NULL);
+
+ cairo_save (cr);
+
+ GTK_STYLE_GET_CLASS (style)->draw_option (style, cr, state_type, shadow_type,
+ widget, detail,
+ x, y, width, height);
+
+ cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_tab:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @shadow_type: the type of shadow to draw
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @x: x origin of the rectangle to draw the tab in
+ * @y: y origin of the rectangle to draw the tab in
+ * @width: the width of the rectangle to draw the tab in
+ * @height: the height of the rectangle to draw the tab in
+ *
+ * Draws an option menu tab (i.e. the up and down pointing arrows)
+ * in the given rectangle on @cr using the given parameters.
+ *
+ * Deprecated:3.0: Use cairo instead
+ */
+void
+gtk_paint_tab (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ g_return_if_fail (GTK_IS_STYLE (style));
+ g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_tab != NULL);
+ g_return_if_fail (cr != NULL);
+
+ cairo_save (cr);
+
+ GTK_STYLE_GET_CLASS (style)->draw_tab (style, cr, state_type, shadow_type,
+ widget, detail,
+ x, y, width, height);
+
+ cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_shadow_gap:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @shadow_type: type of shadow to draw
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @x: x origin of the rectangle
+ * @y: y origin of the rectangle
+ * @width: width of the rectangle
+ * @height: width of the rectangle
+ * @gap_side: side in which to leave the gap
+ * @gap_x: starting position of the gap
+ * @gap_width: width of the gap
+ *
+ * Draws a shadow around the given rectangle in @cr
+ * using the given style and state and shadow type, leaving a
+ * gap in one side.
+ *
+ * Deprecated:3.0: Use gtk_render_frame_gap() instead
+ */
+void
+gtk_paint_shadow_gap (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ GtkPositionType gap_side,
+ gint gap_x,
+ gint gap_width)
+{
+ g_return_if_fail (GTK_IS_STYLE (style));
+ g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_shadow_gap != NULL);
+ g_return_if_fail (cr != NULL);
+ g_return_if_fail (width >= 0);
+ g_return_if_fail (height >= 0);
+
+ cairo_save (cr);
+
+ GTK_STYLE_GET_CLASS (style)->draw_shadow_gap (style, cr, state_type, shadow_type,
+ widget, detail,
+ x, y, width, height, gap_side, gap_x, gap_width);
+
+ cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_box_gap:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @shadow_type: type of shadow to draw
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @x: x origin of the rectangle
+ * @y: y origin of the rectangle
+ * @width: width of the rectangle
+ * @height: width of the rectangle
+ * @gap_side: side in which to leave the gap
+ * @gap_x: starting position of the gap
+ * @gap_width: width of the gap
+ *
+ * Draws a box in @cr using the given style and state and shadow type,
+ * leaving a gap in one side.
+ *
+ * Deprecated:3.0: Use gtk_render_frame_gap() instead
+ */
+void
+gtk_paint_box_gap (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ GtkPositionType gap_side,
+ gint gap_x,
+ gint gap_width)
+{
+ g_return_if_fail (GTK_IS_STYLE (style));
+ g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_box_gap != NULL);
+ g_return_if_fail (cr != NULL);
+ g_return_if_fail (width >= 0);
+ g_return_if_fail (height >= 0);
+
+ cairo_save (cr);
+
+ GTK_STYLE_GET_CLASS (style)->draw_box_gap (style, cr, state_type, shadow_type,
+ widget, detail,
+ x, y, width, height, gap_side, gap_x, gap_width);
+
+ cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_extension:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @shadow_type: type of shadow to draw
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @x: x origin of the extension
+ * @y: y origin of the extension
+ * @width: width of the extension
+ * @height: width of the extension
+ * @gap_side: the side on to which the extension is attached
+ *
+ * Draws an extension, i.e. a notebook tab.
+ *
+ * Deprecated:3.0: Use gtk_render_extension() instead
+ **/
+void
+gtk_paint_extension (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ GtkPositionType gap_side)
+{
+ g_return_if_fail (GTK_IS_STYLE (style));
+ g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_extension != NULL);
+ g_return_if_fail (cr != NULL);
+ g_return_if_fail (width >= 0);
+ g_return_if_fail (height >= 0);
+
+ cairo_save (cr);
+
+ GTK_STYLE_GET_CLASS (style)->draw_extension (style, cr, state_type, shadow_type,
+ widget, detail,
+ x, y, width, height, gap_side);
+
+ cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_focus:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @x: the x origin of the rectangle around which to draw a focus indicator
+ * @y: the y origin of the rectangle around which to draw a focus indicator
+ * @width: the width of the rectangle around which to draw a focus indicator
+ * @height: the height of the rectangle around which to draw a focus indicator
+ *
+ * Draws a focus indicator around the given rectangle on @cr using the
+ * given style.
+ *
+ * Deprecated:3.0: Use gtk_render_focus() instead
+ */
+void
+gtk_paint_focus (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ g_return_if_fail (GTK_IS_STYLE (style));
+ g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_focus != NULL);
+ g_return_if_fail (cr != NULL);
+ g_return_if_fail (width >= 0);
+ g_return_if_fail (height >= 0);
+
+ cairo_save (cr);
+
+ GTK_STYLE_GET_CLASS (style)->draw_focus (style, cr, state_type,
+ widget, detail,
+ x, y, width, height);
+
+ cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_slider:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @shadow_type: a shadow
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @x: the x origin of the rectangle in which to draw a slider
+ * @y: the y origin of the rectangle in which to draw a slider
+ * @width: the width of the rectangle in which to draw a slider
+ * @height: the height of the rectangle in which to draw a slider
+ * @orientation: the orientation to be used
+ *
+ * Draws a slider in the given rectangle on @cr using the
+ * given style and orientation.
+ *
+ * Deprecated:3.0: Use gtk_render_slider() instead
+ **/
+void
+gtk_paint_slider (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ GtkOrientation orientation)
+{
+ g_return_if_fail (GTK_IS_STYLE (style));
+ g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_slider != NULL);
+ g_return_if_fail (cr != NULL);
+ g_return_if_fail (width >= 0);
+ g_return_if_fail (height >= 0);
+
+ cairo_save (cr);
+
+ GTK_STYLE_GET_CLASS (style)->draw_slider (style, cr, state_type, shadow_type,
+ widget, detail,
+ x, y, width, height, orientation);
+
+ cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_handle:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @shadow_type: type of shadow to draw
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @x: x origin of the handle
+ * @y: y origin of the handle
+ * @width: with of the handle
+ * @height: height of the handle
+ * @orientation: the orientation of the handle
+ *
+ * Draws a handle as used in #GtkHandleBox and #GtkPaned.
+ *
+ * Deprecated:3.0: Use gtk_render_handle() instead
+ **/
+void
+gtk_paint_handle (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ GtkOrientation orientation)
+{
+ g_return_if_fail (GTK_IS_STYLE (style));
+ g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_handle != NULL);
+ g_return_if_fail (cr != NULL);
+ g_return_if_fail (width >= 0);
+ g_return_if_fail (height >= 0);
+
+ cairo_save (cr);
+
+ GTK_STYLE_GET_CLASS (style)->draw_handle (style, cr, state_type, shadow_type,
+ widget, detail,
+ x, y, width, height, orientation);
+
+ cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_expander:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @x: the x position to draw the expander at
+ * @y: the y position to draw the expander at
+ * @expander_style: the style to draw the expander in; determines
+ * whether the expander is collapsed, expanded, or in an
+ * intermediate state.
+ *
+ * Draws an expander as used in #GtkTreeView. @x and @y specify the
+ * center the expander. The size of the expander is determined by the
+ * "expander-size" style property of @widget. (If widget is not
+ * specified or doesn't have an "expander-size" property, an
+ * unspecified default size will be used, since the caller doesn't
+ * have sufficient information to position the expander, this is
+ * likely not useful.) The expander is expander_size pixels tall
+ * in the collapsed position and expander_size pixels wide in the
+ * expanded position.
+ *
+ * Deprecated:3.0: Use gtk_render_expander() instead
+ **/
+void
+gtk_paint_expander (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ GtkExpanderStyle expander_style)
+{
+ g_return_if_fail (GTK_IS_STYLE (style));
+ g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_expander != NULL);
+ g_return_if_fail (cr != NULL);
+
+ cairo_save (cr);
+
+ GTK_STYLE_GET_CLASS (style)->draw_expander (style, cr, state_type,
+ widget, detail,
+ x, y, expander_style);
+
+ cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_layout:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @use_text: whether to use the text or foreground
+ * graphics context of @style
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @x: x origin
+ * @y: y origin
+ * @layout: the layout to draw
+ *
+ * Draws a layout on @cr using the given parameters.
+ *
+ * Deprecated:3.0: Use gtk_render_layout() instead
+ **/
+void
+gtk_paint_layout (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ gboolean use_text,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ PangoLayout *layout)
+{
+ g_return_if_fail (GTK_IS_STYLE (style));
+ g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_layout != NULL);
+ g_return_if_fail (cr != NULL);
+
+ cairo_save (cr);
+
+ GTK_STYLE_GET_CLASS (style)->draw_layout (style, cr, state_type, use_text,
+ widget, detail,
+ x, y, layout);
+
+ cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_resize_grip:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @edge: the edge in which to draw the resize grip
+ * @x: the x origin of the rectangle in which to draw the resize grip
+ * @y: the y origin of the rectangle in which to draw the resize grip
+ * @width: the width of the rectangle in which to draw the resize grip
+ * @height: the height of the rectangle in which to draw the resize grip
+ *
+ * Draws a resize grip in the given rectangle on @cr using the given
+ * parameters.
+ *
+ * Deprecated:3.0: Use gtk_render_handle() instead
+ */
+void
+gtk_paint_resize_grip (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ GdkWindowEdge edge,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ g_return_if_fail (GTK_IS_STYLE (style));
+ g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_resize_grip != NULL);
+ g_return_if_fail (cr != NULL);
+
+ cairo_save (cr);
+
+ GTK_STYLE_GET_CLASS (style)->draw_resize_grip (style, cr, state_type,
+ widget, detail,
+ edge, x, y, width, height);
+ cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_spinner:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @widget: (allow-none): the widget (may be %NULL)
+ * @detail: (allow-none): a style detail (may be %NULL)
+ * @step: the nth step, a value between 0 and #GtkSpinner:num-steps
+ * @x: the x origin of the rectangle in which to draw the spinner
+ * @y: the y origin of the rectangle in which to draw the spinner
+ * @width: the width of the rectangle in which to draw the spinner
+ * @height: the height of the rectangle in which to draw the spinner
+ *
+ * Draws a spinner on @window using the given parameters.
+ *
+ * Deprecated:3.0: Use gtk_render_activity() instead
+ */
+void
+gtk_paint_spinner (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ guint step,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ g_return_if_fail (GTK_IS_STYLE (style));
+ g_return_if_fail (cr != NULL);
+ g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_spinner != NULL);
+
+ cairo_save (cr);
+
+ GTK_STYLE_GET_CLASS (style)->draw_spinner (style, cr, state_type,
+ widget, detail,
+ step, x, y, width, height);
+
+ cairo_restore (cr);
+}
--- /dev/null
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
+ * file for a list of people on the GTK+ Team. See the ChangeLog
+ * files for a list of changes. These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
+ */
+
+#if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
+#error "Only <gtk/gtk.h> can be included directly."
+#endif
+
+#ifndef __GTK_STYLE_H__
+#define __GTK_STYLE_H__
+
+
+#include <gdk/gdk.h>
+#include <gtk/gtkenums.h>
+#include <gtk/gtkwidgetpath.h>
+
+
+G_BEGIN_DECLS
+
+#define GTK_TYPE_STYLE (gtk_style_get_type ())
+#define GTK_STYLE(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GTK_TYPE_STYLE, GtkStyle))
+#define GTK_STYLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_STYLE, GtkStyleClass))
+#define GTK_IS_STYLE(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GTK_TYPE_STYLE))
+#define GTK_IS_STYLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_STYLE))
+#define GTK_STYLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_STYLE, GtkStyleClass))
+
+/* Some forward declarations needed to rationalize the header
+ * files.
+ */
+typedef struct _GtkStyleClass GtkStyleClass;
+typedef struct _GtkThemeEngine GtkThemeEngine;
+typedef struct _GtkRcProperty GtkRcProperty;
+
+/**
+ * GTK_STYLE_ATTACHED:
+ * @style: a #GtkStyle.
+ *
+ * Returns whether the style is attached to a window.
+ */
+#define GTK_STYLE_ATTACHED(style) (GTK_STYLE (style)->attach_count > 0)
+
+struct _GtkStyle
+{
+ GObject parent_instance;
+
+ /*< public >*/
+
+ GdkColor fg[5];
+ GdkColor bg[5];
+ GdkColor light[5];
+ GdkColor dark[5];
+ GdkColor mid[5];
+ GdkColor text[5];
+ GdkColor base[5];
+ GdkColor text_aa[5]; /* Halfway between text/base */
+
+ GdkColor black;
+ GdkColor white;
+ PangoFontDescription *font_desc;
+
+ gint xthickness;
+ gint ythickness;
+
+ cairo_pattern_t *background[5];
+
+ /*< private >*/
+
+ gint attach_count;
+
+ GdkVisual *visual;
+ PangoFontDescription *private_font_desc; /* Font description for style->private_font or %NULL */
+
+ /* the RcStyle from which this style was created */
+ GtkRcStyle *rc_style;
+
+ GSList *styles; /* of type GtkStyle* */
+ GArray *property_cache;
+ GSList *icon_factories; /* of type GtkIconFactory* */
+};
+
+struct _GtkStyleClass
+{
+ GObjectClass parent_class;
+
+ /* Initialize for a particular visual. style->visual
+ * will have been set at this point. Will typically chain
+ * to parent.
+ */
+ void (*realize) (GtkStyle *style);
+
+ /* Clean up for a particular visual. Will typically chain
+ * to parent.
+ */
+ void (*unrealize) (GtkStyle *style);
+
+ /* Make style an exact duplicate of src.
+ */
+ void (*copy) (GtkStyle *style,
+ GtkStyle *src);
+
+ /* Create an empty style of the same type as this style.
+ * The default implementation, which does
+ * g_object_new (G_OBJECT_TYPE (style), NULL);
+ * should work in most cases.
+ */
+ GtkStyle *(*clone) (GtkStyle *style);
+
+ /* Initialize the GtkStyle with the values in the GtkRcStyle.
+ * should chain to the parent implementation.
+ */
+ void (*init_from_rc) (GtkStyle *style,
+ GtkRcStyle *rc_style);
+
+ void (*set_background) (GtkStyle *style,
+ GdkWindow *window,
+ GtkStateType state_type);
+
+
+ GdkPixbuf * (* render_icon) (GtkStyle *style,
+ const GtkIconSource *source,
+ GtkTextDirection direction,
+ GtkStateType state,
+ GtkIconSize size,
+ GtkWidget *widget,
+ const gchar *detail);
+
+ /* Drawing functions
+ */
+
+ void (*draw_hline) (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x1,
+ gint x2,
+ gint y);
+ void (*draw_vline) (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint y1_,
+ gint y2_,
+ gint x);
+ void (*draw_shadow) (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+ void (*draw_arrow) (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ GtkArrowType arrow_type,
+ gboolean fill,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+ void (*draw_diamond) (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+ void (*draw_box) (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+ void (*draw_flat_box) (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+ void (*draw_check) (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+ void (*draw_option) (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+ void (*draw_tab) (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+ void (*draw_shadow_gap) (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ GtkPositionType gap_side,
+ gint gap_x,
+ gint gap_width);
+ void (*draw_box_gap) (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ GtkPositionType gap_side,
+ gint gap_x,
+ gint gap_width);
+ void (*draw_extension) (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ GtkPositionType gap_side);
+ void (*draw_focus) (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+ void (*draw_slider) (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ GtkOrientation orientation);
+ void (*draw_handle) (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ GtkOrientation orientation);
+
+ void (*draw_expander) (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ GtkExpanderStyle expander_style);
+ void (*draw_layout) (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ gboolean use_text,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ PangoLayout *layout);
+ void (*draw_resize_grip) (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ GdkWindowEdge edge,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+ void (*draw_spinner) (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ guint step,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+
+ /* Padding for future expansion */
+ void (*_gtk_reserved1) (void);
+ void (*_gtk_reserved2) (void);
+ void (*_gtk_reserved3) (void);
+ void (*_gtk_reserved4) (void);
+ void (*_gtk_reserved5) (void);
+ void (*_gtk_reserved6) (void);
+ void (*_gtk_reserved7) (void);
+ void (*_gtk_reserved8) (void);
+ void (*_gtk_reserved9) (void);
+ void (*_gtk_reserved10) (void);
+ void (*_gtk_reserved11) (void);
+};
+
+GType gtk_style_get_type (void) G_GNUC_CONST;
+GDK_DEPRECATED_FOR(GtkStyleContext)
+GtkStyle* gtk_style_new (void);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+GtkStyle* gtk_style_copy (GtkStyle *style);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+GtkStyle* gtk_style_attach (GtkStyle *style,
+ GdkWindow *window);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_style_detach (GtkStyle *style);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_style_set_background (GtkStyle *style,
+ GdkWindow *window,
+ GtkStateType state_type);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_style_apply_default_background (GtkStyle *style,
+ cairo_t *cr,
+ GdkWindow *window,
+ GtkStateType state_type,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+
+GDK_DEPRECATED_FOR(GtkStyleContext)
+GtkIconSet* gtk_style_lookup_icon_set (GtkStyle *style,
+ const gchar *stock_id);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+gboolean gtk_style_lookup_color (GtkStyle *style,
+ const gchar *color_name,
+ GdkColor *color);
+
+GDK_DEPRECATED_FOR(GtkStyleContext)
+GdkPixbuf* gtk_style_render_icon (GtkStyle *style,
+ const GtkIconSource *source,
+ GtkTextDirection direction,
+ GtkStateType state,
+ GtkIconSize size,
+ GtkWidget *widget,
+ const gchar *detail);
+
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_hline (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x1,
+ gint x2,
+ gint y);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_vline (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint y1_,
+ gint y2_,
+ gint x);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_shadow (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_arrow (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ GtkArrowType arrow_type,
+ gboolean fill,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_diamond (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_box (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_flat_box (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_check (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_option (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_tab (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_shadow_gap (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ GtkPositionType gap_side,
+ gint gap_x,
+ gint gap_width);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_box_gap (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ GtkPositionType gap_side,
+ gint gap_x,
+ gint gap_width);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_extension (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ GtkPositionType gap_side);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_focus (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_slider (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ GtkOrientation orientation);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_handle (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ GtkOrientation orientation);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_expander (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ GtkExpanderStyle expander_style);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_layout (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ gboolean use_text,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ PangoLayout *layout);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_resize_grip (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ GdkWindowEdge edge,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_spinner (GtkStyle *style,
+ cairo_t *cr,
+ GtkStateType state_type,
+ GtkWidget *widget,
+ const gchar *detail,
+ guint step,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_style_get_style_property (GtkStyle *style,
+ GType widget_type,
+ const gchar *property_name,
+ GValue *value);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_style_get_valist (GtkStyle *style,
+ GType widget_type,
+ const gchar *first_property_name,
+ va_list var_args);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_style_get (GtkStyle *style,
+ GType widget_type,
+ const gchar *first_property_name,
+ ...) G_GNUC_NULL_TERMINATED;
+
+
+/* --- private API --- */
+GtkStyle* _gtk_style_new_for_path (GdkScreen *screen,
+ GtkWidgetPath *path);
+void _gtk_style_shade (const GdkColor *a,
+ GdkColor *b,
+ gdouble k);
+
+gboolean gtk_style_has_context (GtkStyle *style);
+
+
+
+G_END_DECLS
+
+#endif /* __GTK_STYLE_H__ */
#include <gtk/gtkradiomenuitem.h>
#include <gtk/gtkradiotoolbutton.h>
#include <gtk/gtkrange.h>
-#include <gtk/gtkrc.h>
#include <gtk/gtkrecentaction.h>
#include <gtk/gtkrecentchooser.h>
#include <gtk/gtkrecentchooserdialog.h>
#include <gtk/gtkstylecontext.h>
#include <gtk/gtkstyleproperties.h>
#include <gtk/gtkstyleprovider.h>
-#include <gtk/gtkstyle.h>
#include <gtk/gtkswitch.h>
#include <gtk/gtksymboliccolor.h>
#include <gtk/gtktextattributes.h>
#include <gtk/deprecated/gtkhscale.h>
#include <gtk/deprecated/gtkhscrollbar.h>
#include <gtk/deprecated/gtkhseparator.h>
+#include <gtk/deprecated/gtkrc.h>
+#include <gtk/deprecated/gtkstyle.h>
#include <gtk/deprecated/gtktable.h>
#include <gtk/deprecated/gtktearoffmenuitem.h>
#include <gtk/deprecated/gtkvbbox.h>
#include "config.h"
+#include "gtkcellrendererspin.h"
+
#include "gtkintl.h"
#include "gtkprivate.h"
#include "gtkspinbutton.h"
-#include "gtkcellrendererspin.h"
/**
#include "gtkbuildable.h"
#include "gtkbuilderprivate.h"
#include "gtktypebuiltins.h"
+#include "deprecated/gtkstyle.h"
/**
#define __GTK_ICON_FACTORY_H__
#include <gdk/gdk.h>
-#include <gtk/gtkrc.h>
+#include <gtk/gtksettings.h>
+#include <gtk/gtkenums.h>
+#include <gtk/gtkwidgetpath.h>
G_BEGIN_DECLS
#define GTK_TYPE_ICON_SET (gtk_icon_set_get_type ())
#define GTK_TYPE_ICON_SOURCE (gtk_icon_source_get_type ())
+typedef struct _GtkIconFactory GtkIconFactory;
typedef struct _GtkIconFactoryPrivate GtkIconFactoryPrivate;
typedef struct _GtkIconFactoryClass GtkIconFactoryClass;
+typedef struct _GtkIconSet GtkIconSet;
+typedef struct _GtkIconSource GtkIconSource;
+
+typedef struct _GtkStyle GtkStyle;
+typedef struct _GtkRcStyle GtkRcStyle;
+
struct _GtkIconFactory
{
GObject parent_instance;
#include "gtknumerableiconprivate.h"
#include "gtksettings.h"
#include "gtkprivate.h"
+#include "deprecated/gtkstyle.h"
/**
#include <gdk-pixbuf/gdk-pixbuf.h>
#include <gdk/gdk.h>
-#include <gtk/gtkstyle.h>
#include <gtk/gtkstylecontext.h>
G_BEGIN_DECLS
#include <string.h>
#include "gtkmodules.h"
-#include "gtkmodulesprivate.h"
#include "gtksettings.h"
#include "gtkdebug.h"
#include "gtkprivate.h"
#ifndef __GTK_MODULES_H__
#define __GTK_MODULES_H__
-#include <gtk/gtksettings.h>
-
+#include <gdk/gdk.h>
G_BEGIN_DECLS
G_BEGIN_DECLS
+#include "gtksettings.h"
+
gchar * _gtk_find_module (const gchar *name,
const gchar *type);
gchar ** _gtk_get_module_path (const gchar *type);
#ifndef __GTK_PLUG_H__
#define __GTK_PLUG_H__
-#include <gtk/gtk.h>
+#include <gdk/gdk.h>
#ifdef GDK_WINDOWING_X11
#include <gdk/gdkx.h>
#include <gtk/gtksocket.h>
+#include <gtk/gtkwindow.h>
G_BEGIN_DECLS
#ifndef __GTK_PRIVATE_H__
#define __GTK_PRIVATE_H__
-#include <glib.h>
-
-#include "gtksettings.h"
+#include <glib-object.h>
+#include <gdk/gdk.h>
G_BEGIN_DECLS
+++ /dev/null
-/* GTK - The GIMP Toolkit
- * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
- */
-
-/*
- * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
- * file for a list of people on the GTK+ Team. See the ChangeLog
- * files for a list of changes. These files are distributed with
- * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
- */
-
-#include "config.h"
-
-#include <locale.h>
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#include <sys/stat.h>
-#ifdef HAVE_SYS_PARAM_H
-#include <sys/param.h>
-#endif
-#include <fcntl.h>
-#include <string.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-
-#include <glib.h>
-#include <glib/gstdio.h>
-#include "gdk/gdk.h"
-
-#include "gtkversion.h"
-#include "gtkrc.h"
-#include "gtkbindings.h"
-#include "gtkintl.h"
-#include "gtkiconfactory.h"
-#include "gtkmain.h"
-#include "gtkmodules.h"
-#include "gtkmodulesprivate.h"
-#include "gtkprivate.h"
-#include "gtksettingsprivate.h"
-#include "gtkwindow.h"
-
-#ifdef G_OS_WIN32
-#include <io.h>
-#endif
-
-
-/**
- * SECTION:gtkrc
- * @Short_description: Deprecated routines for handling resource files
- * @Title: Resource Files
- *
- * GTK+ provides resource file mechanism for configuring
- * various aspects of the operation of a GTK+ program
- * at runtime.
- *
- * <warning>
- * In GTK+ 3.0, resource files have been deprecated and replaced
- * by CSS-like style sheets, which are understood by #GtkCssProvider.
- * </warning>
- *
- * <refsect2>
- * <title>Default files</title>
- * <para>
- * An application can cause GTK+ to parse a specific RC
- * file by calling gtk_rc_parse(). In addition to this,
- * certain files will be read at the end of gtk_init().
- * Unless modified, the files looked for will be
- * <filename><SYSCONFDIR>/gtk-2.0/gtkrc</filename>
- * and <filename>.gtkrc-3.0</filename> in the users home directory.
- * (<filename><SYSCONFDIR></filename> defaults to
- * <filename>/usr/local/etc</filename>. It can be changed with the
- * <option>--prefix</option> or <option>--sysconfdir</option> options when
- * configuring GTK+.)
- *
- * The set of these <firstterm>default</firstterm> files
- * can be retrieved with gtk_rc_get_default_files()
- * and modified with gtk_rc_add_default_file() and
- * gtk_rc_set_default_files().
- * Additionally, the <envar>GTK2_RC_FILES</envar> environment variable
- * can be set to a #G_SEARCHPATH_SEPARATOR_S-separated list of files
- * in order to overwrite the set of default files at runtime.
- * <para><anchor id="locale-specific-rc"/>
- * For each RC file, in addition to the file itself, GTK+ will look for
- * a locale-specific file that will be parsed after the main file.
- * For instance, if <envar>LANG</envar> is set to <literal>ja_JP.ujis</literal>,
- * when loading the default file <filename>~/.gtkrc</filename> then GTK+ looks
- * for <filename>~/.gtkrc.ja_JP</filename> and <filename>~/.gtkrc.ja</filename>,
- * and parses the first of those that exists.</para>
- * </para>
- * </refsect2>
- * <refsect2>
- * <title>Pathnames and patterns</title>
- * <anchor id="gtkrc-pathnames-and-patterns"/>
- * <para>
- * A resource file defines a number of styles and key bindings and
- * attaches them to particular widgets. The attachment is done
- * by the <literal>widget</literal>, <literal>widget_class</literal>,
- * and <literal>class</literal> declarations. As an example
- * of such a statement:
- *
- * <informalexample><programlisting>
- * widget "mywindow.*.GtkEntry" style "my-entry-class"
- * </programlisting></informalexample>
- *
- * attaches the style <literal>"my-entry-class"</literal> to all
- * widgets whose <firstterm>widget path</firstterm> matches the
- * <firstterm>pattern</firstterm> <literal>"mywindow.*.GtkEntry"</literal>.
- * That is, all #GtkEntry widgets which are part of a #GtkWindow named
- * <literal>"mywindow"</literal>.
- *
- * The patterns here are given in the standard shell glob syntax.
- * The <literal>"?"</literal> wildcard matches any character, while
- * <literal>"*"</literal> matches zero or more of any character.
- * The three types of matching are against the widget path, the
- * <firstterm>class path</firstterm> and the class hierarchy. Both the
- * widget path and the class path consist of a <literal>"."</literal>
- * separated list of all the parents of the widget and the widget itself
- * from outermost to innermost. The difference is that in the widget path,
- * the name assigned by gtk_widget_set_name() is used if present, otherwise
- * the class name of the widget, while for the class path, the class name is
- * always used.
- *
- * Since GTK+ 2.10, <literal>widget_class</literal> paths can also contain
- * <literal><classname></literal> substrings, which are matching
- * the class with the given name and any derived classes. For instance,
- * <informalexample><programlisting>
- * widget_class "*<GtkMenuItem>.GtkLabel" style "my-style"
- * </programlisting></informalexample>
- * will match #GtkLabel widgets which are contained in any kind of menu item.
- *
- * So, if you have a #GtkEntry named <literal>"myentry"</literal>, inside of a
- * horizontal box in a window named <literal>"mywindow"</literal>, then the
- * widget path is: <literal>"mywindow.GtkHBox.myentry"</literal>
- * while the class path is: <literal>"GtkWindow.GtkHBox.GtkEntry"</literal>.
- *
- * Matching against class is a little different. The pattern match is done
- * against all class names in the widgets class hierarchy (not the layout
- * hierarchy) in sequence, so the pattern:
- * <informalexample><programlisting>
- * class "GtkButton" style "my-style"
- * </programlisting></informalexample>
- * will match not just #GtkButton widgets, but also #GtkToggleButton and
- * #GtkCheckButton widgets, since those classes derive from #GtkButton.
- *
- * Additionally, a priority can be specified for each pattern, and styles
- * override other styles first by priority, then by pattern type and then
- * by order of specification (later overrides earlier). The priorities
- * that can be specified are (highest to lowest):
- * <simplelist>
- * <member><literal>highest</literal></member>
- * <member><literal>rc</literal></member>
- * <member><literal>theme</literal></member>
- * <member><literal>application</literal></member>
- * <member><literal>gtk</literal></member>
- * <member><literal>lowest</literal></member>
- * </simplelist>
- * <literal>rc</literal> is the default for styles
- * read from an RC file, <literal>theme</literal>
- * is the default for styles read from theme RC files,
- * <literal>application</literal>
- * should be used for styles an application sets
- * up, and <literal>gtk</literal> is used for styles
- * that GTK+ creates internally.
- * </para>
- * </refsect2>
- * <refsect2>
- * <title>Theme gtkrc files</title>
- * <anchor id="theme-gtkrc-files"/>
- * <para>
- * Theme RC files are loaded first from under the <filename>~/.themes/</filename>,
- * then from the directory from gtk_rc_get_theme_dir(). The files looked at will
- * be <filename>gtk-3.0/gtkrc</filename>.
- *
- * When the application prefers dark themes
- * (see the #GtkSettings:gtk-application-prefer-dark-theme property for details),
- * <filename>gtk-3.0/gtkrc-dark</filename> will be loaded first, and if not present
- * <filename>gtk-3.0/gtkrc</filename> will be loaded.
- * </para>
- * </refsect2>
- * <refsect2>
- * <title>Optimizing RC Style Matches</title>
- * <anchor id="optimizing-rc-style-matches"/>
- * <para>
- * Everytime a widget is created and added to the layout hierarchy of a #GtkWindow
- * ("anchored" to be exact), a list of matching RC styles out of all RC styles read
- * in so far is composed.
- * For this, every RC style is matched against the widgets class path,
- * the widgets name path and widgets inheritance hierarchy.
- * As a consequence, significant slowdown can be caused by utilization of many
- * RC styles and by using RC style patterns that are slow or complicated to match
- * against a given widget.
- * The following ordered list provides a number of advices (prioritized by
- * effectiveness) to reduce the performance overhead associated with RC style
- * matches:
- *
- * <orderedlist>
- * <listitem><para>
- * Move RC styles for specific applications into RC files dedicated to those
- * applications and parse application specific RC files only from
- * applications that are affected by them.
- * This reduces the overall amount of RC styles that have to be considered
- * for a match across a group of applications.
- * </para></listitem>
- * <listitem><para>
- * Merge multiple styles which use the same matching rule, for instance:
- * <informalexample><programlisting>
- * style "Foo" { foo_content }
- * class "X" style "Foo"
- * style "Bar" { bar_content }
- * class "X" style "Bar"
- * </programlisting></informalexample>
- * is faster to match as:
- * <informalexample><programlisting>
- * style "FooBar" { foo_content bar_content }
- * class "X" style "FooBar"
- * </programlisting></informalexample>
- * </para></listitem>
- * <listitem><para>
- * Use of wildcards should be avoided, this can reduce the individual RC style
- * match to a single integer comparison in most cases.
- * </para></listitem>
- * <listitem><para>
- * To avoid complex recursive matching, specification of full class names
- * (for <literal>class</literal> matches) or full path names (for
- * <literal>widget</literal> and <literal>widget_class</literal> matches)
- * is to be preferred over shortened names
- * containing <literal>"*"</literal> or <literal>"?"</literal>.
- * </para></listitem>
- * <listitem><para>
- * If at all necessary, wildcards should only be used at the tail or head
- * of a pattern. This reduces the match complexity to a string comparison
- * per RC style.
- * </para></listitem>
- * <listitem><para>
- * When using wildcards, use of <literal>"?"</literal> should be preferred
- * over <literal>"*"</literal>. This can reduce the matching complexity from
- * O(n^2) to O(n). For example <literal>"Gtk*Box"</literal> can be turned into
- * <literal>"Gtk?Box"</literal> and will still match #GtkHBox and #GtkVBox.
- * </para></listitem>
- * <listitem><para>
- * The use of <literal>"*"</literal> wildcards should be restricted as much
- * as possible, because matching <literal>"A*B*C*RestString"</literal> can
- * result in matching complexities of O(n^2) worst case.
- * </para></listitem>
- * </orderedlist>
- * </para>
- * </refsect2>
- * <refsect2>
- * <title>Toplevel declarations</title>
- * <para>
- * An RC file is a text file which is composed of a sequence
- * of declarations. <literal>'#'</literal> characters delimit comments and
- * the portion of a line after a <literal>'#'</literal> is ignored when parsing
- * an RC file.
- *
- * The possible toplevel declarations are:
- *
- * <variablelist>
- * <varlistentry>
- * <term><literal>binding <replaceable>name</replaceable>
- * { ... }</literal></term>
- * <listitem>
- * <para>Declares a binding set.</para>
- * </listitem>
- * </varlistentry>
- * <varlistentry>
- * <term><literal>class <replaceable>pattern</replaceable>
- * [ style | binding ][ : <replaceable>priority</replaceable> ]
- * <replaceable>name</replaceable></literal></term>
- * <listitem>
- * <para>Specifies a style or binding set for a particular
- * branch of the inheritance hierarchy.</para>
- * </listitem>
- * </varlistentry>
- * <varlistentry>
- * <term><literal>include <replaceable>filename</replaceable></literal></term>
- * <listitem>
- * <para>Parses another file at this point. If
- * <replaceable>filename</replaceable> is not an absolute filename,
- * it is searched in the directories of the currently open RC files.</para>
- * <para>GTK+ also tries to load a
- * <link linkend="locale-specific-rc">locale-specific variant</link> of
- * the included file.</para>
- * </listitem>
- * </varlistentry>
- * <varlistentry>
- * <term><literal>module_path <replaceable>path</replaceable></literal></term>
- * <listitem>
- * <para>Sets a path (a list of directories separated
- * by colons) that will be searched for theme engines referenced in
- * RC files.</para>
- * </listitem>
- * </varlistentry>
- * <varlistentry>
- * <term><literal>pixmap_path <replaceable>path</replaceable></literal></term>
- * <listitem>
- * <para>Sets a path (a list of directories separated
- * by colons) that will be searched for pixmaps referenced in
- * RC files.</para>
- * </listitem>
- * </varlistentry>
- * <varlistentry>
- * <term><literal>im_module_file <replaceable>pathname</replaceable></literal></term>
- * <listitem>
- * <para>Sets the pathname for the IM modules file. Setting this from RC files
- * is deprecated; you should use the environment variable <envar>GTK_IM_MODULE_FILE</envar>
- * instead.</para>
- * </listitem>
- * </varlistentry>
- * <varlistentry>
- * <term><literal>style <replaceable>name</replaceable> [ =
- * <replaceable>parent</replaceable> ] { ... }</literal></term>
- * <listitem>
- * <para>Declares a style.</para>
- * </listitem>
- * </varlistentry>
- * <varlistentry>
- * <term><literal>widget <replaceable>pattern</replaceable>
- * [ style | binding ][ : <replaceable>priority</replaceable> ]
- * <replaceable>name</replaceable></literal></term>
- * <listitem>
- * <para>Specifies a style or binding set for a particular
- * group of widgets by matching on the widget pathname.</para>
- * </listitem>
- * </varlistentry>
- * <varlistentry>
- * <term><literal>widget_class <replaceable>pattern</replaceable>
- * [ style | binding ][ : <replaceable>priority</replaceable> ]
- * <replaceable>name</replaceable></literal></term>
- * <listitem>
- * <para>Specifies a style or binding set for a particular
- * group of widgets by matching on the class pathname.</para>
- * </listitem>
- * </varlistentry>
- * <varlistentry>
- * <term><replaceable>setting</replaceable> = <replaceable>value</replaceable></term>
- * <listitem>
- * <para>Specifies a value for a <link linkend="GtkSettings">setting</link>.
- * Note that settings in RC files are overwritten by system-wide settings
- * (which are managed by an XSettings manager on X11).</para>
- * </listitem>
- * </varlistentry>
- * </variablelist>
- * </para>
- * </refsect2>
- * <refsect2>
- * <title>Styles</title>
- * <para>
- * A RC style is specified by a <literal>style</literal>
- * declaration in a RC file, and then bound to widgets
- * with a <literal>widget</literal>, <literal>widget_class</literal>,
- * or <literal>class</literal> declaration. All styles
- * applying to a particular widget are composited together
- * with <literal>widget</literal> declarations overriding
- * <literal>widget_class</literal> declarations which, in
- * turn, override <literal>class</literal> declarations.
- * Within each type of declaration, later declarations override
- * earlier ones.
- *
- * Within a <literal>style</literal> declaration, the possible
- * elements are:
- *
- * <variablelist>
- * <varlistentry>
- * <term><literal>bg[<replaceable>state</replaceable>] =
- * <replaceable>color</replaceable></literal></term>
- * <listitem>
- * Sets the color used for the background of most widgets.
- * </listitem>
- * </varlistentry>
- * <varlistentry>
- * <term><literal>fg[<replaceable>state</replaceable>] =
- * <replaceable>color</replaceable></literal></term>
- * <listitem>
- * Sets the color used for the foreground of most widgets.
- * </listitem>
- * </varlistentry>
- * <varlistentry>
- * <term><literal>base[<replaceable>state</replaceable>] =
- * <replaceable>color</replaceable></literal></term>
- * <listitem>
- * Sets the color used for the background of widgets displaying
- * editable text. This color is used for the background
- * of, among others, #GtkText, #GtkEntry, #GtkList, and #GtkCList.
- * </listitem>
- * </varlistentry>
- * <varlistentry>
- * <term><literal>text[<replaceable>state</replaceable>] =
- * <replaceable>color</replaceable></literal></term>
- * <listitem>
- * Sets the color used for foreground of widgets using
- * <literal>base</literal> for the background color.
- * </listitem>
- * </varlistentry>
- * <varlistentry>
- * <term><literal>xthickness =
- * <replaceable>number</replaceable></literal></term>
- * <listitem>
- * Sets the xthickness, which is used for various horizontal padding
- * values in GTK+.
- * </listitem>
- * </varlistentry>
- * <varlistentry>
- * <term><literal>ythickness =
- * <replaceable>number</replaceable></literal></term>
- * <listitem>
- * Sets the ythickness, which is used for various vertical padding
- * values in GTK+.
- * </listitem>
- * </varlistentry>
- * <varlistentry>
- * <term><literal>bg_pixmap[<replaceable>state</replaceable>] =
- * <replaceable>pixmap</replaceable></literal></term>
- * <listitem>
- * Sets a background pixmap to be used in place of
- * the <literal>bg</literal> color (or for #GtkText,
- * in place of the <literal>base</literal> color. The special
- * value <literal>"<parent>"</literal> may be used to indicate that the widget should
- * use the same background pixmap as its parent. The special value
- * <literal>"<none>"</literal> may be used to indicate no background pixmap.
- * </listitem>
- * </varlistentry>
- * <varlistentry>
- * <term><literal>font = <replaceable>font</replaceable></literal></term>
- * <listitem>
- * Starting with GTK+ 2.0, the "font" and "fontset"
- * declarations are ignored; use "font_name" declarations instead.
- * </listitem>
- * </varlistentry>
- * <varlistentry>
- * <term><literal>fontset = <replaceable>font</replaceable></literal></term>
- * <listitem>
- * Starting with GTK+ 2.0, the "font" and "fontset"
- * declarations are ignored; use "font_name" declarations instead.
- * </listitem>
- * </varlistentry>
- * <varlistentry>
- * <term><literal>font_name = <replaceable>font</replaceable></literal></term>
- * <listitem>
- * Sets the font for a widget. <replaceable>font</replaceable> must be
- * a Pango font name, e.g. <literal>"Sans Italic 10"</literal>.
- * For details about Pango font names, see
- * pango_font_description_from_string().
- * </listitem>
- * </varlistentry>
- * <varlistentry>
- * <term><literal>stock[<replaceable>"stock-id"</replaceable>] = { <replaceable>icon source specifications</replaceable> }</literal></term>
- * <listitem>
- * Defines the icon for a stock item.
- * </listitem>
- * </varlistentry>
- * <varlistentry>
- * <term><literal>color[<replaceable>"color-name"</replaceable>] = <replaceable>color specification</replaceable></literal></term>
- * <listitem>
- * Since 2.10, this element can be used to defines symbolic colors. See below for
- * the syntax of color specifications.
- * </listitem>
- * </varlistentry>
- * <varlistentry>
- * <term><literal>engine <replaceable>"engine"</replaceable> { <replaceable>engine-specific
- * settings</replaceable> }</literal></term>
- * <listitem>
- * Defines the engine to be used when drawing with this style.
- * </listitem>
- * </varlistentry>
- * <varlistentry>
- * <term><literal><replaceable>class</replaceable>::<replaceable>property</replaceable> = <replaceable>value</replaceable></literal></term>
- * <listitem>
- * Sets a <link linkend="style-properties">style property</link> for a widget class.
- * </listitem>
- * </varlistentry>
- * </variablelist>
- *
- * The colors and background pixmaps are specified as a function of the
- * state of the widget. The states are:
- *
- * <variablelist>
- * <varlistentry>
- * <term><literal>NORMAL</literal></term>
- * <listitem>
- * A color used for a widget in its normal state.
- * </listitem>
- * </varlistentry>
- * <varlistentry>
- * <term><literal>ACTIVE</literal></term>
- * <listitem>
- * A variant of the <literal>NORMAL</literal> color used when the
- * widget is in the %GTK_STATE_ACTIVE state, and also for
- * the trough of a ScrollBar, tabs of a NoteBook
- * other than the current tab and similar areas.
- * Frequently, this should be a darker variant
- * of the <literal>NORMAL</literal> color.
- * </listitem>
- * </varlistentry>
- * <varlistentry>
- * <term><literal>PRELIGHT</literal></term>
- * <listitem>
- * A color used for widgets in the %GTK_STATE_PRELIGHT state. This
- * state is the used for Buttons and MenuItems
- * that have the mouse cursor over them, and for
- * their children.
- * </listitem>
- * </varlistentry>
- * <varlistentry>
- * <term><literal>SELECTED</literal></term>
- * <listitem>
- * A color used to highlight data selected by the user.
- * for instance, the selected items in a list widget, and the
- * selection in an editable widget.
- * </listitem>
- * </varlistentry>
- * <varlistentry>
- * <term><literal>INSENSITIVE</literal></term>
- * <listitem>
- * A color used for the background of widgets that have
- * been set insensitive with gtk_widget_set_sensitive().
- * </listitem>
- * </varlistentry>
- * </variablelist>
- *
- * <anchor id="color-format"/>
- * Colors can be specified as a string containing a color name (GTK+ knows
- * all names from the X color database <filename>/usr/lib/X11/rgb.txt</filename>),
- * in one of the hexadecimal forms <literal>#rrrrggggbbbb</literal>,
- * <literal>#rrrgggbbb</literal>, <literal>#rrggbb</literal>,
- * or <literal>#rgb</literal>, where <literal>r</literal>,
- * <literal>g</literal> and <literal>b</literal> are
- * hex digits, or they can be specified as a triplet
- * <literal>{ <replaceable>r</replaceable>, <replaceable>g</replaceable>,
- * <replaceable>b</replaceable>}</literal>, where <literal>r</literal>,
- * <literal>g</literal> and <literal>b</literal> are either integers in
- * the range 0-65535 or floats in the range 0.0-1.0.
- *
- * Since 2.10, colors can also be specified by refering to a symbolic color, as
- * follows: <literal>@<!-- -->color-name</literal>, or by using expressions to combine
- * colors. The following expressions are currently supported:
- * <variablelist>
- * <varlistentry>
- * <term>mix (<replaceable>factor</replaceable>, <replaceable>color1</replaceable>, <replaceable>color2</replaceable>)</term>
- * <listitem><para>
- * Computes a new color by mixing <replaceable>color1</replaceable> and
- * <replaceable>color2</replaceable>. The <replaceable>factor</replaceable>
- * determines how close the new color is to <replaceable>color1</replaceable>.
- * A factor of 1.0 gives pure <replaceable>color1</replaceable>, a factor of
- * 0.0 gives pure <replaceable>color2</replaceable>.
- * </para></listitem>
- * </varlistentry>
- * <varlistentry>
- * <term>shade (<replaceable>factor</replaceable>, <replaceable>color</replaceable>)</term>
- * <listitem><para>
- * Computes a lighter or darker variant of <replaceable>color</replaceable>.
- * A <replaceable>factor</replaceable> of 1.0 leaves the color unchanged, smaller
- * factors yield darker colors, larger factors yield lighter colors.
- * </para></listitem>
- * </varlistentry>
- * <varlistentry>
- * <term>lighter (<replaceable>color</replaceable>)</term>
- * <listitem><para>
- * This is an abbreviation for
- * <literal>shade (1.3, <replaceable>color</replaceable>)</literal>.
- * </para></listitem>
- * </varlistentry>
- * <varlistentry>
- * <term>darker (<replaceable>color</replaceable>)</term>
- * <listitem><para>
- * This is an abbreviation for
- * <literal>shade (0.7, <replaceable>color</replaceable>)</literal>.
- * </para></listitem>
- * </varlistentry>
- * </variablelist>
- *
- * Here are some examples of color expressions:
- *
- * <informalexample><programlisting>
- * mix (0.5, "red", "blue")
- * shade (1.5, mix (0.3, "#0abbc0", { 0.3, 0.5, 0.9 }))
- * lighter (@<!-- -->foreground)
- * </programlisting></informalexample>
- *
- * In a <literal>stock</literal> definition, icon sources are specified as a
- * 4-tuple of image filename or icon name, text direction, widget state, and size, in that
- * order. Each icon source specifies an image filename or icon name to use with a given
- * direction, state, and size. Filenames are specified as a string such
- * as <literal>"itemltr.png"</literal>, while icon names (looked up
- * in the current icon theme), are specified with a leading
- * <literal>@</literal>, such as <literal>@"item-ltr"</literal>.
- * The <literal>*</literal> character can be used as a
- * wildcard, and if direction/state/size are omitted they default to
- * <literal>*</literal>. So for example, the following specifies different icons to
- * use for left-to-right and right-to-left languages:
- *
- * <informalexample><programlisting>
- * stock["my-stock-item"] =
- * {
- * { "itemltr.png", LTR, *, * },
- * { "itemrtl.png", RTL, *, * }
- * }
- * </programlisting></informalexample>
- *
- * This could be abbreviated as follows:
- *
- * <informalexample><programlisting>
- * stock["my-stock-item"] =
- * {
- * { "itemltr.png", LTR },
- * { "itemrtl.png", RTL }
- * }
- * </programlisting></informalexample>
- *
- * You can specify custom icons for specific sizes, as follows:
- *
- * <informalexample><programlisting>
- * stock["my-stock-item"] =
- * {
- * { "itemmenusize.png", *, *, "gtk-menu" },
- * { "itemtoolbarsize.png", *, *, "gtk-large-toolbar" }
- * { "itemgeneric.png" } // implicit *, *, * as a fallback
- * }
- * </programlisting></informalexample>
- *
- * The sizes that come with GTK+ itself are <literal>"gtk-menu"</literal>,
- * <literal>"gtk-small-toolbar"</literal>, <literal>"gtk-large-toolbar"</literal>,
- * <literal>"gtk-button"</literal>, <literal>"gtk-dialog"</literal>. Applications
- * can define other sizes.
- *
- * It's also possible to use custom icons for a given state, for example:
- *
- * <informalexample><programlisting>
- * stock["my-stock-item"] =
- * {
- * { "itemprelight.png", *, PRELIGHT },
- * { "iteminsensitive.png", *, INSENSITIVE },
- * { "itemgeneric.png" } // implicit *, *, * as a fallback
- * }
- * </programlisting></informalexample>
- *
- * When selecting an icon source to use, GTK+ will consider text direction most
- * important, state second, and size third. It will select the best match based on
- * those criteria. If an attribute matches exactly (e.g. you specified
- * <literal>PRELIGHT</literal> or specified the size), GTK+ won't modify the image;
- * if the attribute matches with a wildcard, GTK+ will scale or modify the image to
- * match the state and size the user requested.
- * </para>
- * </refsect2>
- * <refsect2>
- * <title>Key bindings</title>
- * <para>
- * Key bindings allow the user to specify actions to be
- * taken on particular key presses. The form of a binding
- * set declaration is:
- *
- * <informalexample><programlisting>
- * binding <replaceable>name</replaceable> {
- * bind <replaceable>key</replaceable> {
- * <replaceable>signalname</replaceable> (<replaceable>param</replaceable>, ...)
- * ...
- * }
- * ...
- * }
- * </programlisting></informalexample>
- *
- * <replaceable>key</replaceable> is a string consisting of a
- * series of modifiers followed by the name of a key. The
- * modifiers can be:
- * <simplelist>
- * <member><literal><alt></literal></member>
- * <member><literal><ctl></literal></member>
- * <member><literal><control></literal></member>
- * <member><literal><meta></literal></member>
- * <member><literal><hyper></literal></member>
- * <member><literal><super></literal></member>
- * <member><literal><mod1></literal></member>
- * <member><literal><mod2></literal></member>
- * <member><literal><mod3></literal></member>
- * <member><literal><mod4></literal></member>
- * <member><literal><mod5></literal></member>
- * <member><literal><release></literal></member>
- * <member><literal><shft></literal></member>
- * <member><literal><shift></literal></member>
- * </simplelist>
- * <literal><shft></literal> is an alias for
- * <literal><shift></literal>,
- * <literal><ctl></literal> is an alias for
- * <literal><control></literal>,
- * and
- * <literal><alt></literal> is an alias for
- * <literal><mod1></literal>.
- *
- * The action that is bound to the key is a sequence
- * of signal names (strings) followed by parameters for
- * each signal. The signals must be action signals.
- * (See g_signal_new()). Each parameter can be
- * a float, integer, string, or unquoted string
- * representing an enumeration value. The types of
- * the parameters specified must match the types of the
- * parameters of the signal.
- *
- * Binding sets are connected to widgets in the same manner as styles,
- * with one difference: Binding sets override other binding sets first
- * by pattern type, then by priority and then by order of specification.
- * The priorities that can be specified and their default values are the
- * same as for styles.
- * </para>
- * </refsect2>
- */
-
-
-enum
-{
- PATH_ELT_PSPEC,
- PATH_ELT_UNRESOLVED,
- PATH_ELT_TYPE
-};
-
-typedef struct
-{
- gint type;
- union
- {
- GType class_type;
- gchar *class_name;
- GPatternSpec *pspec;
- } elt;
-} PathElt;
-
-#define GTK_RC_STYLE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_RC_STYLE, GtkRcStylePrivate))
-
-typedef struct _GtkRcStylePrivate GtkRcStylePrivate;
-
-struct _GtkRcStylePrivate
-{
- GSList *color_hashes;
-};
-
-static void gtk_rc_style_finalize (GObject *object);
-static void gtk_rc_style_real_merge (GtkRcStyle *dest,
- GtkRcStyle *src);
-static GtkRcStyle* gtk_rc_style_real_create_rc_style (GtkRcStyle *rc_style);
-static GtkStyle* gtk_rc_style_real_create_style (GtkRcStyle *rc_style);
-static gint gtk_rc_properties_cmp (gconstpointer bsearch_node1,
- gconstpointer bsearch_node2);
-
-static void insert_rc_property (GtkRcStyle *style,
- GtkRcProperty *property,
- gboolean replace);
-
-
-static const GScannerConfig gtk_rc_scanner_config =
-{
- (
- " \t\r\n"
- ) /* cset_skip_characters */,
- (
- "_"
- G_CSET_a_2_z
- G_CSET_A_2_Z
- ) /* cset_identifier_first */,
- (
- G_CSET_DIGITS
- "-_"
- G_CSET_a_2_z
- G_CSET_A_2_Z
- ) /* cset_identifier_nth */,
- ( "#\n" ) /* cpair_comment_single */,
-
- TRUE /* case_sensitive */,
-
- TRUE /* skip_comment_multi */,
- TRUE /* skip_comment_single */,
- TRUE /* scan_comment_multi */,
- TRUE /* scan_identifier */,
- FALSE /* scan_identifier_1char */,
- FALSE /* scan_identifier_NULL */,
- TRUE /* scan_symbols */,
- TRUE /* scan_binary */,
- TRUE /* scan_octal */,
- TRUE /* scan_float */,
- TRUE /* scan_hex */,
- TRUE /* scan_hex_dollar */,
- TRUE /* scan_string_sq */,
- TRUE /* scan_string_dq */,
- TRUE /* numbers_2_int */,
- FALSE /* int_2_float */,
- FALSE /* identifier_2_string */,
- TRUE /* char_2_token */,
- TRUE /* symbol_2_token */,
- FALSE /* scope_0_fallback */,
-};
-
-static const gchar symbol_names[] =
- "include\0"
- "NORMAL\0"
- "ACTIVE\0"
- "PRELIGHT\0"
- "SELECTED\0"
- "INSENSITIVE\0"
- "fg\0"
- "bg\0"
- "text\0"
- "base\0"
- "xthickness\0"
- "ythickness\0"
- "font\0"
- "fontset\0"
- "font_name\0"
- "bg_pixmap\0"
- "pixmap_path\0"
- "style\0"
- "binding\0"
- "bind\0"
- "widget\0"
- "widget_class\0"
- "class\0"
- "lowest\0"
- "gtk\0"
- "application\0"
- "theme\0"
- "rc\0"
- "highest\0"
- "engine\0"
- "module_path\0"
- "stock\0"
- "im_module_file\0"
- "LTR\0"
- "RTL\0"
- "color\0"
- "unbind\0";
-
-static const struct
-{
- guint name_offset;
- guint token;
-} symbols[] = {
- { 0, GTK_RC_TOKEN_INCLUDE },
- { 8, GTK_RC_TOKEN_NORMAL },
- { 15, GTK_RC_TOKEN_ACTIVE },
- { 22, GTK_RC_TOKEN_PRELIGHT },
- { 31, GTK_RC_TOKEN_SELECTED },
- { 40, GTK_RC_TOKEN_INSENSITIVE },
- { 52, GTK_RC_TOKEN_FG },
- { 55, GTK_RC_TOKEN_BG },
- { 58, GTK_RC_TOKEN_TEXT },
- { 63, GTK_RC_TOKEN_BASE },
- { 68, GTK_RC_TOKEN_XTHICKNESS },
- { 79, GTK_RC_TOKEN_YTHICKNESS },
- { 90, GTK_RC_TOKEN_FONT },
- { 95, GTK_RC_TOKEN_FONTSET },
- { 103, GTK_RC_TOKEN_FONT_NAME },
- { 113, GTK_RC_TOKEN_BG_PIXMAP },
- { 123, GTK_RC_TOKEN_PIXMAP_PATH },
- { 135, GTK_RC_TOKEN_STYLE },
- { 141, GTK_RC_TOKEN_BINDING },
- { 149, GTK_RC_TOKEN_BIND },
- { 154, GTK_RC_TOKEN_WIDGET },
- { 161, GTK_RC_TOKEN_WIDGET_CLASS },
- { 174, GTK_RC_TOKEN_CLASS },
- { 180, GTK_RC_TOKEN_LOWEST },
- { 187, GTK_RC_TOKEN_GTK },
- { 191, GTK_RC_TOKEN_APPLICATION },
- { 203, GTK_RC_TOKEN_THEME },
- { 209, GTK_RC_TOKEN_RC },
- { 212, GTK_RC_TOKEN_HIGHEST },
- { 220, GTK_RC_TOKEN_ENGINE },
- { 227, GTK_RC_TOKEN_MODULE_PATH },
- { 239, GTK_RC_TOKEN_STOCK },
- { 245, GTK_RC_TOKEN_IM_MODULE_FILE },
- { 260, GTK_RC_TOKEN_LTR },
- { 264, GTK_RC_TOKEN_RTL },
- { 268, GTK_RC_TOKEN_COLOR },
- { 274, GTK_RC_TOKEN_UNBIND }
-};
-
-static GHashTable *realized_style_ht = NULL;
-
-static gchar *im_module_file = NULL;
-
-static gchar **gtk_rc_default_files = NULL;
-
-/* RC file handling */
-
-static gchar *
-gtk_rc_make_default_dir (const gchar *type)
-{
- const gchar *var;
- gchar *path;
-
- var = g_getenv ("GTK_EXE_PREFIX");
-
- if (var)
- path = g_build_filename (var, "lib", "gtk-3.0", GTK_BINARY_VERSION, type, NULL);
- else
- path = g_build_filename (_gtk_get_libdir (), "gtk-3.0", GTK_BINARY_VERSION, type, NULL);
-
- return path;
-}
-
-/**
- * gtk_rc_get_im_module_path:
- *
- * Obtains the path in which to look for IM modules. See the documentation
- * of the <link linkend="im-module-path"><envar>GTK_PATH</envar></link>
- * environment variable for more details about looking up modules. This
- * function is useful solely for utilities supplied with GTK+ and should
- * not be used by applications under normal circumstances.
- *
- * Returns: (type filename): a newly-allocated string containing the
- * path in which to look for IM modules.
- *
- * Deprecated: 3.0: Use #GtkCssProvider instead.
- */
-gchar *
-gtk_rc_get_im_module_path (void)
-{
- gchar **paths = _gtk_get_module_path ("immodules");
- gchar *result = g_strjoinv (G_SEARCHPATH_SEPARATOR_S, paths);
- g_strfreev (paths);
-
- return result;
-}
-
-/**
- * gtk_rc_get_im_module_file:
- *
- * Obtains the path to the IM modules file. See the documentation
- * of the <link linkend="im-module-file"><envar>GTK_IM_MODULE_FILE</envar></link>
- * environment variable for more details.
- *
- * Returns: (type filename): a newly-allocated string containing the
- * name of the file listing the IM modules available for loading
- *
- * Deprecated: 3.0: Use #GtkCssProvider instead.
- */
-gchar *
-gtk_rc_get_im_module_file (void)
-{
- const gchar *var = g_getenv ("GTK_IM_MODULE_FILE");
- gchar *result = NULL;
-
- if (var)
- result = g_strdup (var);
-
- if (!result)
- {
- if (im_module_file)
- result = g_strdup (im_module_file);
- else
- result = gtk_rc_make_default_dir ("immodules.cache");
- }
-
- return result;
-}
-
-/**
- * gtk_rc_get_theme_dir:
- *
- * Returns the standard directory in which themes should
- * be installed. (GTK+ does not actually use this directory
- * itself.)
- *
- * Returns: The directory (must be freed with g_free()).
- *
- * Deprecated: 3.0: Use #GtkCssProvider instead.
- */
-gchar *
-gtk_rc_get_theme_dir (void)
-{
- const gchar *var;
- gchar *path;
-
- var = g_getenv ("GTK_DATA_PREFIX");
-
- if (var)
- path = g_build_filename (var, "share", "themes", NULL);
- else
- path = g_build_filename (_gtk_get_data_prefix (), "share", "themes", NULL);
-
- return path;
-}
-
-/**
- * gtk_rc_get_module_dir:
- *
- * Returns a directory in which GTK+ looks for theme engines.
- * For full information about the search for theme engines,
- * see the docs for <envar>GTK_PATH</envar> in
- * <xref linkend="gtk-running"/>.
- *
- * return value: (type filename): the directory. (Must be freed with g_free())
- *
- * Deprecated: 3.0: Use #GtkCssProvider instead.
- **/
-gchar *
-gtk_rc_get_module_dir (void)
-{
- return gtk_rc_make_default_dir ("engines");
-}
-
-/**
- * gtk_rc_add_default_file:
- * @filename: (type filename): the pathname to the file. If @filename
- * is not absolute, it is searched in the current directory.
- *
- * Adds a file to the list of files to be parsed at the
- * end of gtk_init().
- *
- * Deprecated:3.0: Use #GtkStyleContext with a custom #GtkStyleProvider instead
- **/
-void
-gtk_rc_add_default_file (const gchar *filename)
-{
-}
-
-/**
- * gtk_rc_set_default_files:
- * @filenames: (array zero-terminated=1) (element-type filename): A
- * %NULL-terminated list of filenames.
- *
- * Sets the list of files that GTK+ will read at the
- * end of gtk_init().
- *
- * Deprecated:3.0: Use #GtkStyleContext with a custom #GtkStyleProvider instead
- **/
-void
-gtk_rc_set_default_files (gchar **filenames)
-{
-}
-
-/**
- * gtk_rc_get_default_files:
- *
- * Retrieves the current list of RC files that will be parsed
- * at the end of gtk_init().
- *
- * Return value: (transfer none) (array zero-terminated=1) (element-type filename):
- * A %NULL-terminated array of filenames. This memory is owned
- * by GTK+ and must not be freed by the application. If you want
- * to store this information, you should make a copy.
- *
- * Deprecated:3.0: Use #GtkStyleContext instead
- **/
-gchar **
-gtk_rc_get_default_files (void)
-{
- return gtk_rc_default_files;
-}
-
-/**
- * gtk_rc_parse_string:
- * @rc_string: a string to parse.
- *
- * Parses resource information directly from a string.
- *
- * Deprecated: 3.0: Use #GtkCssProvider instead.
- */
-void
-gtk_rc_parse_string (const gchar *rc_string)
-{
- g_return_if_fail (rc_string != NULL);
-}
-
-/**
- * gtk_rc_parse:
- * @filename: the filename of a file to parse. If @filename is not absolute, it
- * is searched in the current directory.
- *
- * Parses a given resource file.
- *
- * Deprecated: 3.0: Use #GtkCssProvider instead.
- */
-void
-gtk_rc_parse (const gchar *filename)
-{
- g_return_if_fail (filename != NULL);
-}
-
-/* Handling of RC styles */
-
-G_DEFINE_TYPE (GtkRcStyle, gtk_rc_style, G_TYPE_OBJECT)
-
-static void
-gtk_rc_style_init (GtkRcStyle *style)
-{
- GtkRcStylePrivate *priv = GTK_RC_STYLE_GET_PRIVATE (style);
- guint i;
-
- style->name = NULL;
- style->font_desc = NULL;
-
- for (i = 0; i < 5; i++)
- {
- static const GdkColor init_color = { 0, 0, 0, 0, };
-
- style->bg_pixmap_name[i] = NULL;
- style->color_flags[i] = 0;
- style->fg[i] = init_color;
- style->bg[i] = init_color;
- style->text[i] = init_color;
- style->base[i] = init_color;
- }
- style->xthickness = -1;
- style->ythickness = -1;
- style->rc_properties = NULL;
-
- style->rc_style_lists = NULL;
- style->icon_factories = NULL;
-
- priv->color_hashes = NULL;
-}
-
-static void
-gtk_rc_style_class_init (GtkRcStyleClass *klass)
-{
- GObjectClass *object_class = G_OBJECT_CLASS (klass);
-
- object_class->finalize = gtk_rc_style_finalize;
-
- klass->parse = NULL;
- klass->create_rc_style = gtk_rc_style_real_create_rc_style;
- klass->merge = gtk_rc_style_real_merge;
- klass->create_style = gtk_rc_style_real_create_style;
-
- g_type_class_add_private (object_class, sizeof (GtkRcStylePrivate));
-}
-
-static void
-gtk_rc_style_finalize (GObject *object)
-{
- GSList *tmp_list1, *tmp_list2;
- GtkRcStyle *rc_style;
- GtkRcStylePrivate *rc_priv;
- gint i;
-
- rc_style = GTK_RC_STYLE (object);
- rc_priv = GTK_RC_STYLE_GET_PRIVATE (rc_style);
-
- g_free (rc_style->name);
- if (rc_style->font_desc)
- pango_font_description_free (rc_style->font_desc);
-
- for (i = 0; i < 5; i++)
- g_free (rc_style->bg_pixmap_name[i]);
-
- /* Now remove all references to this rc_style from
- * realized_style_ht
- */
- tmp_list1 = rc_style->rc_style_lists;
- while (tmp_list1)
- {
- GSList *rc_styles = tmp_list1->data;
- GtkStyle *style = g_hash_table_lookup (realized_style_ht, rc_styles);
- g_object_unref (style);
-
- /* Remove the list of styles from the other rc_styles
- * in the list
- */
- tmp_list2 = rc_styles;
- while (tmp_list2)
- {
- GtkRcStyle *other_style = tmp_list2->data;
-
- if (other_style != rc_style)
- other_style->rc_style_lists = g_slist_remove_all (other_style->rc_style_lists,
- rc_styles);
- tmp_list2 = tmp_list2->next;
- }
-
- /* And from the hash table itself
- */
- g_hash_table_remove (realized_style_ht, rc_styles);
- g_slist_free (rc_styles);
-
- tmp_list1 = tmp_list1->next;
- }
- g_slist_free (rc_style->rc_style_lists);
-
- if (rc_style->rc_properties)
- {
- guint i;
-
- for (i = 0; i < rc_style->rc_properties->len; i++)
- {
- GtkRcProperty *node = &g_array_index (rc_style->rc_properties, GtkRcProperty, i);
-
- g_free (node->origin);
- g_value_unset (&node->value);
- }
- g_array_free (rc_style->rc_properties, TRUE);
- rc_style->rc_properties = NULL;
- }
-
- g_slist_foreach (rc_style->icon_factories, (GFunc) g_object_unref, NULL);
- g_slist_free (rc_style->icon_factories);
-
- g_slist_foreach (rc_priv->color_hashes, (GFunc) g_hash_table_unref, NULL);
- g_slist_free (rc_priv->color_hashes);
-
- G_OBJECT_CLASS (gtk_rc_style_parent_class)->finalize (object);
-}
-
-/**
- * gtk_rc_style_new:
- *
- * Creates a new #GtkRcStyle with no fields set and
- * a reference count of 1.
- *
- * Returns: the newly-created #GtkRcStyle
- *
- * Deprecated: 3.0: Use #GtkCssProvider instead.
- */
-GtkRcStyle *
-gtk_rc_style_new (void)
-{
- GtkRcStyle *style;
-
- style = g_object_new (GTK_TYPE_RC_STYLE, NULL);
-
- return style;
-}
-
-/**
- * gtk_rc_style_copy:
- * @orig: the style to copy
- *
- * Makes a copy of the specified #GtkRcStyle. This function
- * will correctly copy an RC style that is a member of a class
- * derived from #GtkRcStyle.
- *
- * Return value: (transfer full): the resulting #GtkRcStyle
- *
- * Deprecated: 3.0: Use #GtkCssProvider instead.
- **/
-GtkRcStyle *
-gtk_rc_style_copy (GtkRcStyle *orig)
-{
- GtkRcStyle *style;
-
- g_return_val_if_fail (GTK_IS_RC_STYLE (orig), NULL);
-
- style = GTK_RC_STYLE_GET_CLASS (orig)->create_rc_style (orig);
- GTK_RC_STYLE_GET_CLASS (style)->merge (style, orig);
-
- return style;
-}
-
-static GtkRcStyle *
-gtk_rc_style_real_create_rc_style (GtkRcStyle *style)
-{
- return g_object_new (G_OBJECT_TYPE (style), NULL);
-}
-
-static gint
-gtk_rc_properties_cmp (gconstpointer bsearch_node1,
- gconstpointer bsearch_node2)
-{
- const GtkRcProperty *prop1 = bsearch_node1;
- const GtkRcProperty *prop2 = bsearch_node2;
-
- if (prop1->type_name == prop2->type_name)
- return prop1->property_name < prop2->property_name ? -1 : prop1->property_name == prop2->property_name ? 0 : 1;
- else
- return prop1->type_name < prop2->type_name ? -1 : 1;
-}
-
-static void
-insert_rc_property (GtkRcStyle *style,
- GtkRcProperty *property,
- gboolean replace)
-{
- guint i;
- GtkRcProperty *new_property = NULL;
- GtkRcProperty key = { 0, 0, NULL, { 0, }, };
-
- key.type_name = property->type_name;
- key.property_name = property->property_name;
-
- if (!style->rc_properties)
- style->rc_properties = g_array_new (FALSE, FALSE, sizeof (GtkRcProperty));
-
- i = 0;
- while (i < style->rc_properties->len)
- {
- gint cmp = gtk_rc_properties_cmp (&key, &g_array_index (style->rc_properties, GtkRcProperty, i));
-
- if (cmp == 0)
- {
- if (replace)
- {
- new_property = &g_array_index (style->rc_properties, GtkRcProperty, i);
-
- g_free (new_property->origin);
- g_value_unset (&new_property->value);
-
- *new_property = key;
- break;
- }
- else
- return;
- }
- else if (cmp < 0)
- break;
-
- i++;
- }
-
- if (!new_property)
- {
- g_array_insert_val (style->rc_properties, i, key);
- new_property = &g_array_index (style->rc_properties, GtkRcProperty, i);
- }
-
- new_property->origin = g_strdup (property->origin);
- g_value_init (&new_property->value, G_VALUE_TYPE (&property->value));
- g_value_copy (&property->value, &new_property->value);
-}
-
-static void
-gtk_rc_style_real_merge (GtkRcStyle *dest,
- GtkRcStyle *src)
-{
- gint i;
-
- for (i = 0; i < 5; i++)
- {
- if (!dest->bg_pixmap_name[i] && src->bg_pixmap_name[i])
- dest->bg_pixmap_name[i] = g_strdup (src->bg_pixmap_name[i]);
-
- if (!(dest->color_flags[i] & GTK_RC_FG) &&
- src->color_flags[i] & GTK_RC_FG)
- {
- dest->fg[i] = src->fg[i];
- dest->color_flags[i] |= GTK_RC_FG;
- }
- if (!(dest->color_flags[i] & GTK_RC_BG) &&
- src->color_flags[i] & GTK_RC_BG)
- {
- dest->bg[i] = src->bg[i];
- dest->color_flags[i] |= GTK_RC_BG;
- }
- if (!(dest->color_flags[i] & GTK_RC_TEXT) &&
- src->color_flags[i] & GTK_RC_TEXT)
- {
- dest->text[i] = src->text[i];
- dest->color_flags[i] |= GTK_RC_TEXT;
- }
- if (!(dest->color_flags[i] & GTK_RC_BASE) &&
- src->color_flags[i] & GTK_RC_BASE)
- {
- dest->base[i] = src->base[i];
- dest->color_flags[i] |= GTK_RC_BASE;
- }
- }
-
- if (dest->xthickness < 0 && src->xthickness >= 0)
- dest->xthickness = src->xthickness;
- if (dest->ythickness < 0 && src->ythickness >= 0)
- dest->ythickness = src->ythickness;
-
- if (src->font_desc)
- {
- if (!dest->font_desc)
- dest->font_desc = pango_font_description_copy (src->font_desc);
- else
- pango_font_description_merge (dest->font_desc, src->font_desc, FALSE);
- }
-
- if (src->rc_properties)
- {
- guint i;
-
- for (i = 0; i < src->rc_properties->len; i++)
- insert_rc_property (dest,
- &g_array_index (src->rc_properties, GtkRcProperty, i),
- FALSE);
- }
-}
-
-static GtkStyle *
-gtk_rc_style_real_create_style (GtkRcStyle *rc_style)
-{
- return gtk_style_new ();
-}
-
-/**
- * gtk_rc_reset_styles:
- * @settings: a #GtkSettings
- *
- * This function recomputes the styles for all widgets that use a
- * particular #GtkSettings object. (There is one #GtkSettings object
- * per #GdkScreen, see gtk_settings_get_for_screen()); It is useful
- * when some global parameter has changed that affects the appearance
- * of all widgets, because when a widget gets a new style, it will
- * both redraw and recompute any cached information about its
- * appearance. As an example, it is used when the default font size
- * set by the operating system changes. Note that this function
- * doesn't affect widgets that have a style set explicitely on them
- * with gtk_widget_set_style().
- *
- * Since: 2.4
- *
- * Deprecated: 3.0: Use #GtkCssProvider instead.
- **/
-void
-gtk_rc_reset_styles (GtkSettings *settings)
-{
- gtk_style_context_reset_widgets (_gtk_settings_get_screen (settings));
-}
-
-/**
- * gtk_rc_reparse_all_for_settings:
- * @settings: a #GtkSettings
- * @force_load: load whether or not anything changed
- *
- * If the modification time on any previously read file
- * for the given #GtkSettings has changed, discard all style information
- * and then reread all previously read RC files.
- *
- * Return value: %TRUE if the files were reread.
- *
- * Deprecated: 3.0: Use #GtkCssProvider instead.
- **/
-gboolean
-gtk_rc_reparse_all_for_settings (GtkSettings *settings,
- gboolean force_load)
-{
- return FALSE;
-}
-
-/**
- * gtk_rc_reparse_all:
- *
- * If the modification time on any previously read file for the
- * default #GtkSettings has changed, discard all style information
- * and then reread all previously read RC files.
- *
- * Return value: %TRUE if the files were reread.
- *
- * Deprecated: 3.0: Use #GtkCssProvider instead.
- **/
-gboolean
-gtk_rc_reparse_all (void)
-{
- return FALSE;
-}
-
-/**
- * gtk_rc_get_style:
- * @widget: a #GtkWidget
- *
- * Finds all matching RC styles for a given widget,
- * composites them together, and then creates a
- * #GtkStyle representing the composite appearance.
- * (GTK+ actually keeps a cache of previously
- * created styles, so a new style may not be
- * created.)
- *
- * Returns: (transfer none): the resulting style. No refcount is added
- * to the returned style, so if you want to save this style around,
- * you should add a reference yourself.
- *
- * Deprecated:3.0: Use #GtkStyleContext instead
- **/
-GtkStyle *
-gtk_rc_get_style (GtkWidget *widget)
-{
- g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
-
- gtk_widget_ensure_style (widget);
-
- return gtk_widget_get_style (widget);
-}
-
-/**
- * gtk_rc_get_style_by_paths:
- * @settings: a #GtkSettings object
- * @widget_path: (allow-none): the widget path to use when looking up the
- * style, or %NULL if no matching against the widget path should be done
- * @class_path: (allow-none): the class path to use when looking up the style,
- * or %NULL if no matching against the class path should be done.
- * @type: a type that will be used along with parent types of this type
- * when matching against class styles, or #G_TYPE_NONE
- *
- * Creates up a #GtkStyle from styles defined in a RC file by providing
- * the raw components used in matching. This function may be useful
- * when creating pseudo-widgets that should be themed like widgets but
- * don't actually have corresponding GTK+ widgets. An example of this
- * would be items inside a GNOME canvas widget.
- *
- * The action of gtk_rc_get_style() is similar to:
- * |[
- * gtk_widget_path (widget, NULL, &path, NULL);
- * gtk_widget_class_path (widget, NULL, &class_path, NULL);
- * gtk_rc_get_style_by_paths (gtk_widget_get_settings (widget),
- * path, class_path,
- * G_OBJECT_TYPE (widget));
- * ]|
- *
- * Return value: (transfer none): A style created by matching with the
- * supplied paths, or %NULL if nothing matching was specified and the
- * default style should be used. The returned value is owned by GTK+
- * as part of an internal cache, so you must call g_object_ref() on
- * the returned value if you want to keep a reference to it.
- *
- * Deprecated:3.0: Use #GtkStyleContext instead
- **/
-GtkStyle *
-gtk_rc_get_style_by_paths (GtkSettings *settings,
- const char *widget_path,
- const char *class_path,
- GType type)
-{
- GtkWidgetPath *path;
- GtkStyle *style;
-
- path = gtk_widget_path_new ();
-
- /* For compatibility, we return a GtkStyle based on a GtkStyleContext
- * with a GtkWidgetPath appropriate for the supplied information.
- *
- * GtkWidgetPath is composed of a list of GTypes with optional names;
- * In GTK+-2.0, widget_path consisted of the widget names, or
- * the class names for unnamed widgets, while class_path had the
- * class names always. So, use class_path to determine the GTypes
- * and extract widget names from widget_path as applicable.
- */
- if (class_path == NULL)
- {
- gtk_widget_path_append_type (path, type == G_TYPE_NONE ? GTK_TYPE_WIDGET : type);
- }
- else
- {
- const gchar *widget_p, *widget_next;
- const gchar *class_p, *class_next;
-
- widget_next = widget_path;
- class_next = class_path;
-
- while (*class_next)
- {
- GType component_type;
- gchar *component_class;
- gchar *component_name;
- gint pos;
-
- class_p = class_next;
- if (*class_p == '.')
- class_p++;
-
- widget_p = widget_next; /* Might be NULL */
- if (widget_p && *widget_p == '.')
- widget_p++;
-
- class_next = strchr (class_p, '.');
- if (class_next == NULL)
- class_next = class_p + strlen (class_p);
-
- if (widget_p)
- {
- widget_next = strchr (widget_p, '.');
- if (widget_next == NULL)
- widget_next = widget_p + strlen (widget_p);
- }
-
- component_class = g_strndup (class_p, class_next - class_p);
- if (widget_p && *widget_p)
- component_name = g_strndup (widget_p, widget_next - widget_p);
- else
- component_name = NULL;
-
- component_type = g_type_from_name (component_class);
- if (component_type == G_TYPE_INVALID)
- component_type = GTK_TYPE_WIDGET;
-
- pos = gtk_widget_path_append_type (path, component_type);
- if (component_name != NULL && strcmp (component_name, component_name) != 0)
- gtk_widget_path_iter_set_name (path, pos, component_name);
-
- g_free (component_class);
- g_free (component_name);
- }
- }
-
- style = _gtk_style_new_for_path (_gtk_settings_get_screen (settings),
- path);
-
- gtk_widget_path_free (path);
-
- return style;
-}
-
-/**
- * gtk_rc_scanner_new: (skip)
- *
- * Deprecated:3.0: Use #GtkCssProvider instead
- */
-GScanner*
-gtk_rc_scanner_new (void)
-{
- return g_scanner_new (>k_rc_scanner_config);
-}
-
-/*********************
- * Parsing functions *
- *********************/
-
-static gboolean
-lookup_color (GtkRcStyle *style,
- const char *color_name,
- GdkColor *color)
-{
- GtkRcStylePrivate *priv = GTK_RC_STYLE_GET_PRIVATE (style);
- GSList *iter;
-
- for (iter = priv->color_hashes; iter != NULL; iter = iter->next)
- {
- GHashTable *hash = iter->data;
- GdkColor *match = g_hash_table_lookup (hash, color_name);
-
- if (match)
- {
- color->red = match->red;
- color->green = match->green;
- color->blue = match->blue;
- return TRUE;
- }
- }
-
- return FALSE;
-}
-
-/**
- * gtk_rc_find_pixmap_in_path:
- * @settings: a #GtkSettings
- * @scanner: Scanner used to get line number information for the
- * warning message, or %NULL
- * @pixmap_file: name of the pixmap file to locate.
- *
- * Looks up a file in pixmap path for the specified #GtkSettings.
- * If the file is not found, it outputs a warning message using
- * g_warning() and returns %NULL.
- *
- * Return value: (type filename): the filename.
- *
- * Deprecated: 3.0: Use #GtkCssProvider instead.
- **/
-gchar*
-gtk_rc_find_pixmap_in_path (GtkSettings *settings,
- GScanner *scanner,
- const gchar *pixmap_file)
-{
- g_warning ("Unable to locate image file in pixmap_path: \"%s\"",
- pixmap_file);
- return NULL;
-}
-
-/**
- * gtk_rc_find_module_in_path:
- * @module_file: name of a theme engine
- *
- * Searches for a theme engine in the GTK+ search path. This function
- * is not useful for applications and should not be used.
- *
- * Return value: (type filename): The filename, if found (must be
- * freed with g_free()), otherwise %NULL.
- *
- * Deprecated: 3.0: Use #GtkCssProvider instead.
- **/
-gchar*
-gtk_rc_find_module_in_path (const gchar *module_file)
-{
- return _gtk_find_module (module_file, "engines");
-}
-
-/**
- * gtk_rc_parse_state:
- * @scanner: a #GtkScanner (must be initialized for parsing an RC file)
- * @state: (out): A pointer to a #GtkStateType variable in which to
- * store the result.
- *
- * Parses a #GtkStateType variable from the format expected
- * in a RC file.
- *
- * Returns: %G_TOKEN_NONE if parsing succeeded, otherwise the token
- * that was expected but not found.
- *
- * Deprecated: 3.0: Use #GtkCssProvider instead
- */
-guint
-gtk_rc_parse_state (GScanner *scanner,
- GtkStateType *state)
-{
- guint old_scope;
- guint token;
-
- g_return_val_if_fail (scanner != NULL, G_TOKEN_ERROR);
- g_return_val_if_fail (state != NULL, G_TOKEN_ERROR);
-
- /* we don't know where we got called from, so we reset the scope here.
- * if we bail out due to errors, we *don't* reset the scope, so the
- * error messaging code can make sense of our tokens.
- */
- old_scope = g_scanner_set_scope (scanner, 0);
-
- token = g_scanner_get_next_token (scanner);
- if (token != G_TOKEN_LEFT_BRACE)
- return G_TOKEN_LEFT_BRACE;
-
- token = g_scanner_get_next_token (scanner);
- switch (token)
- {
- case GTK_RC_TOKEN_ACTIVE:
- *state = GTK_STATE_ACTIVE;
- break;
- case GTK_RC_TOKEN_INSENSITIVE:
- *state = GTK_STATE_INSENSITIVE;
- break;
- case GTK_RC_TOKEN_NORMAL:
- *state = GTK_STATE_NORMAL;
- break;
- case GTK_RC_TOKEN_PRELIGHT:
- *state = GTK_STATE_PRELIGHT;
- break;
- case GTK_RC_TOKEN_SELECTED:
- *state = GTK_STATE_SELECTED;
- break;
- default:
- return /* G_TOKEN_SYMBOL */ GTK_RC_TOKEN_NORMAL;
- }
-
- token = g_scanner_get_next_token (scanner);
- if (token != G_TOKEN_RIGHT_BRACE)
- return G_TOKEN_RIGHT_BRACE;
-
- g_scanner_set_scope (scanner, old_scope);
-
- return G_TOKEN_NONE;
-}
-
-/**
- * gtk_rc_parse_priority:
- * @scanner: a #GtkScanner (must be initialized for parsing an RC file)
- * @priority: A pointer to #GtkPathPriorityType variable in which
- * to store the result.
- *
- * Parses a #GtkPathPriorityType variable from the format expected
- * in a RC file.
- *
- * Returns: %G_TOKEN_NONE if parsing succeeded, otherwise the token
- * that was expected but not found.
- *
- * Deprecated:3.0: Use #GtkCssProvider instead
- */
-guint
-gtk_rc_parse_priority (GScanner *scanner,
- GtkPathPriorityType *priority)
-{
- guint old_scope;
- guint token;
-
- g_return_val_if_fail (scanner != NULL, G_TOKEN_ERROR);
- g_return_val_if_fail (priority != NULL, G_TOKEN_ERROR);
-
- /* we don't know where we got called from, so we reset the scope here.
- * if we bail out due to errors, we *don't* reset the scope, so the
- * error messaging code can make sense of our tokens.
- */
- old_scope = g_scanner_set_scope (scanner, 0);
-
- token = g_scanner_get_next_token (scanner);
- if (token != ':')
- return ':';
-
- token = g_scanner_get_next_token (scanner);
- switch (token)
- {
- case GTK_RC_TOKEN_LOWEST:
- *priority = GTK_PATH_PRIO_LOWEST;
- break;
- case GTK_RC_TOKEN_GTK:
- *priority = GTK_PATH_PRIO_GTK;
- break;
- case GTK_RC_TOKEN_APPLICATION:
- *priority = GTK_PATH_PRIO_APPLICATION;
- break;
- case GTK_RC_TOKEN_THEME:
- *priority = GTK_PATH_PRIO_THEME;
- break;
- case GTK_RC_TOKEN_RC:
- *priority = GTK_PATH_PRIO_RC;
- break;
- case GTK_RC_TOKEN_HIGHEST:
- *priority = GTK_PATH_PRIO_HIGHEST;
- break;
- default:
- return /* G_TOKEN_SYMBOL */ GTK_RC_TOKEN_APPLICATION;
- }
-
- g_scanner_set_scope (scanner, old_scope);
-
- return G_TOKEN_NONE;
-}
-
-/**
- * gtk_rc_parse_color:
- * @scanner: a #GScanner
- * @color: (out): a pointer to a #GdkColor structure in which to store
- * the result
- *
- * Parses a color in the <link linkend="color=format">format</link> expected
- * in a RC file.
- *
- * Note that theme engines should use gtk_rc_parse_color_full() in
- * order to support symbolic colors.
- *
- * Returns: %G_TOKEN_NONE if parsing succeeded, otherwise the token
- * that was expected but not found
- *
- * Deprecated:3.0: Use #GtkCssProvider instead
- */
-guint
-gtk_rc_parse_color (GScanner *scanner,
- GdkColor *color)
-{
- return gtk_rc_parse_color_full (scanner, NULL, color);
-}
-
-/**
- * gtk_rc_parse_color_full:
- * @scanner: a #GScanner
- * @style: (allow-none): a #GtkRcStyle, or %NULL
- * @color: (out): a pointer to a #GdkColor structure in which to store
- * the result
- *
- * Parses a color in the <link linkend="color=format">format</link> expected
- * in a RC file. If @style is not %NULL, it will be consulted to resolve
- * references to symbolic colors.
- *
- * Returns: %G_TOKEN_NONE if parsing succeeded, otherwise the token
- * that was expected but not found
- *
- * Since: 2.12
- *
- * Deprecated:3.0: Use #GtkCssProvider instead
- */
-guint
-gtk_rc_parse_color_full (GScanner *scanner,
- GtkRcStyle *style,
- GdkColor *color)
-{
- guint token;
-
- g_return_val_if_fail (scanner != NULL, G_TOKEN_ERROR);
-
- /* we don't need to set our own scope here, because
- * we don't need own symbols
- */
-
- token = g_scanner_get_next_token (scanner);
- switch (token)
- {
- gint token_int;
- GdkColor c1, c2;
- gboolean negate;
- gdouble l;
-
- case G_TOKEN_LEFT_CURLY:
- token = g_scanner_get_next_token (scanner);
- if (token == G_TOKEN_INT)
- token_int = scanner->value.v_int;
- else if (token == G_TOKEN_FLOAT)
- token_int = scanner->value.v_float * 65535.0;
- else
- return G_TOKEN_FLOAT;
- color->red = CLAMP (token_int, 0, 65535);
-
- token = g_scanner_get_next_token (scanner);
- if (token != G_TOKEN_COMMA)
- return G_TOKEN_COMMA;
-
- token = g_scanner_get_next_token (scanner);
- if (token == G_TOKEN_INT)
- token_int = scanner->value.v_int;
- else if (token == G_TOKEN_FLOAT)
- token_int = scanner->value.v_float * 65535.0;
- else
- return G_TOKEN_FLOAT;
- color->green = CLAMP (token_int, 0, 65535);
-
- token = g_scanner_get_next_token (scanner);
- if (token != G_TOKEN_COMMA)
- return G_TOKEN_COMMA;
-
- token = g_scanner_get_next_token (scanner);
- if (token == G_TOKEN_INT)
- token_int = scanner->value.v_int;
- else if (token == G_TOKEN_FLOAT)
- token_int = scanner->value.v_float * 65535.0;
- else
- return G_TOKEN_FLOAT;
- color->blue = CLAMP (token_int, 0, 65535);
-
- token = g_scanner_get_next_token (scanner);
- if (token != G_TOKEN_RIGHT_CURLY)
- return G_TOKEN_RIGHT_CURLY;
- return G_TOKEN_NONE;
-
- case G_TOKEN_STRING:
- if (!gdk_color_parse (scanner->value.v_string, color))
- {
- g_scanner_warn (scanner, "Invalid color constant '%s'",
- scanner->value.v_string);
- return G_TOKEN_STRING;
- }
- return G_TOKEN_NONE;
-
- case '@':
- token = g_scanner_get_next_token (scanner);
- if (token != G_TOKEN_IDENTIFIER)
- return G_TOKEN_IDENTIFIER;
-
- if (!style || !lookup_color (style, scanner->value.v_identifier, color))
- {
- g_scanner_warn (scanner, "Invalid symbolic color '%s'",
- scanner->value.v_identifier);
- return G_TOKEN_IDENTIFIER;
- }
-
- return G_TOKEN_NONE;
-
- case G_TOKEN_IDENTIFIER:
- if (strcmp (scanner->value.v_identifier, "mix") == 0)
- {
- token = g_scanner_get_next_token (scanner);
- if (token != G_TOKEN_LEFT_PAREN)
- return G_TOKEN_LEFT_PAREN;
-
- negate = FALSE;
- if (g_scanner_peek_next_token (scanner) == '-')
- {
- g_scanner_get_next_token (scanner); /* eat sign */
- negate = TRUE;
- }
-
- token = g_scanner_get_next_token (scanner);
- if (token != G_TOKEN_FLOAT)
- return G_TOKEN_FLOAT;
-
- l = negate ? -scanner->value.v_float : scanner->value.v_float;
-
- token = g_scanner_get_next_token (scanner);
- if (token != G_TOKEN_COMMA)
- return G_TOKEN_COMMA;
-
- token = gtk_rc_parse_color_full (scanner, style, &c1);
- if (token != G_TOKEN_NONE)
- return token;
-
- token = g_scanner_get_next_token (scanner);
- if (token != G_TOKEN_COMMA)
- return G_TOKEN_COMMA;
-
- token = gtk_rc_parse_color_full (scanner, style, &c2);
- if (token != G_TOKEN_NONE)
- return token;
-
- token = g_scanner_get_next_token (scanner);
- if (token != G_TOKEN_RIGHT_PAREN)
- return G_TOKEN_RIGHT_PAREN;
-
- color->red = l * c1.red + (1.0 - l) * c2.red;
- color->green = l * c1.green + (1.0 - l) * c2.green;
- color->blue = l * c1.blue + (1.0 - l) * c2.blue;
-
- return G_TOKEN_NONE;
- }
- else if (strcmp (scanner->value.v_identifier, "shade") == 0)
- {
- token = g_scanner_get_next_token (scanner);
- if (token != G_TOKEN_LEFT_PAREN)
- return G_TOKEN_LEFT_PAREN;
-
- negate = FALSE;
- if (g_scanner_peek_next_token (scanner) == '-')
- {
- g_scanner_get_next_token (scanner); /* eat sign */
- negate = TRUE;
- }
-
- token = g_scanner_get_next_token (scanner);
- if (token != G_TOKEN_FLOAT)
- return G_TOKEN_FLOAT;
-
- l = negate ? -scanner->value.v_float : scanner->value.v_float;
-
- token = g_scanner_get_next_token (scanner);
- if (token != G_TOKEN_COMMA)
- return G_TOKEN_COMMA;
-
- token = gtk_rc_parse_color_full (scanner, style, &c1);
- if (token != G_TOKEN_NONE)
- return token;
-
- token = g_scanner_get_next_token (scanner);
- if (token != G_TOKEN_RIGHT_PAREN)
- return G_TOKEN_RIGHT_PAREN;
-
- _gtk_style_shade (&c1, color, l);
-
- return G_TOKEN_NONE;
- }
- else if (strcmp (scanner->value.v_identifier, "lighter") == 0 ||
- strcmp (scanner->value.v_identifier, "darker") == 0)
- {
- if (scanner->value.v_identifier[0] == 'l')
- l = 1.3;
- else
- l = 0.7;
-
- token = g_scanner_get_next_token (scanner);
- if (token != G_TOKEN_LEFT_PAREN)
- return G_TOKEN_LEFT_PAREN;
-
- token = gtk_rc_parse_color_full (scanner, style, &c1);
- if (token != G_TOKEN_NONE)
- return token;
-
- token = g_scanner_get_next_token (scanner);
- if (token != G_TOKEN_RIGHT_PAREN)
- return G_TOKEN_RIGHT_PAREN;
-
- _gtk_style_shade (&c1, color, l);
-
- return G_TOKEN_NONE;
- }
- else
- return G_TOKEN_IDENTIFIER;
-
- default:
- return G_TOKEN_STRING;
- }
-}
+++ /dev/null
-/* GTK - The GIMP Toolkit
- * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
- */
-
-/*
- * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
- * file for a list of people on the GTK+ Team. See the ChangeLog
- * files for a list of changes. These files are distributed with
- * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
- */
-
-#if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
-#error "Only <gtk/gtk.h> can be included directly."
-#endif
-
-#ifndef __GTK_RC_H__
-#define __GTK_RC_H__
-
-
-#include <gtk/gtkstyle.h>
-
-G_BEGIN_DECLS
-
-/* Forward declarations */
-typedef struct _GtkIconFactory GtkIconFactory;
-typedef struct _GtkRcContext GtkRcContext;
-
-typedef struct _GtkRcStyleClass GtkRcStyleClass;
-
-#define GTK_TYPE_RC_STYLE (gtk_rc_style_get_type ())
-#define GTK_RC_STYLE(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GTK_TYPE_RC_STYLE, GtkRcStyle))
-#define GTK_RC_STYLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_RC_STYLE, GtkRcStyleClass))
-#define GTK_IS_RC_STYLE(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GTK_TYPE_RC_STYLE))
-#define GTK_IS_RC_STYLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_RC_STYLE))
-#define GTK_RC_STYLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_RC_STYLE, GtkRcStyleClass))
-
-typedef enum
-{
- GTK_RC_FG = 1 << 0,
- GTK_RC_BG = 1 << 1,
- GTK_RC_TEXT = 1 << 2,
- GTK_RC_BASE = 1 << 3
-} GtkRcFlags;
-
-/**
- * GtkRcStyle:
- * @name:
- * @bg_pixmap_name:
- * @font_desc:
- * @color_flags:
- * @fg:
- * @bg:
- * @text:
- * @base:
- * @xthickness:
- * @ythickness:
- *
- * The #GtkRcStyle structure is used to represent a set
- * of information about the appearance of a widget.
- * This can later be composited together with other
- * #GtkRcStyle structures to form a #GtkStyle.
- */
-struct _GtkRcStyle
-{
- GObject parent_instance;
-
- /*< public >*/
-
- gchar *name;
- gchar *bg_pixmap_name[5];
- PangoFontDescription *font_desc;
-
- GtkRcFlags color_flags[5];
- GdkColor fg[5];
- GdkColor bg[5];
- GdkColor text[5];
- GdkColor base[5];
-
- gint xthickness;
- gint ythickness;
-
- /*< private >*/
- GArray *rc_properties;
-
- /* list of RC style lists including this RC style */
- GSList *rc_style_lists;
-
- GSList *icon_factories;
-
- guint engine_specified : 1; /* The RC file specified the engine */
-};
-
-struct _GtkRcStyleClass
-{
- GObjectClass parent_class;
-
- /* Create an empty RC style of the same type as this RC style.
- * The default implementation, which does
- * g_object_new (G_OBJECT_TYPE (style), NULL);
- * should work in most cases.
- */
- GtkRcStyle * (*create_rc_style) (GtkRcStyle *rc_style);
-
- /* Fill in engine specific parts of GtkRcStyle by parsing contents
- * of brackets. Returns G_TOKEN_NONE if successful, otherwise returns
- * the token it expected but didn't get.
- */
- guint (*parse) (GtkRcStyle *rc_style,
- GtkSettings *settings,
- GScanner *scanner);
-
- /* Combine RC style data from src into dest. If overridden, this
- * function should chain to the parent.
- */
- void (*merge) (GtkRcStyle *dest,
- GtkRcStyle *src);
-
- /* Create an empty style suitable to this RC style
- */
- GtkStyle * (*create_style) (GtkRcStyle *rc_style);
-
- /* Padding for future expansion */
- void (*_gtk_reserved1) (void);
- void (*_gtk_reserved2) (void);
- void (*_gtk_reserved3) (void);
- void (*_gtk_reserved4) (void);
-};
-
-GSList* _gtk_rc_parse_widget_class_path (const gchar *pattern);
-void _gtk_rc_free_widget_class_path (GSList *list);
-gboolean _gtk_rc_match_widget_class (GSList *list,
- gint length,
- gchar *path,
- gchar *path_reversed);
-
-#if !defined(GTK_DISABLE_DEPRECATED) || defined(GTK_COMPILATION)
-GDK_DEPRECATED_FOR(GtkStyleContext)
-void gtk_rc_add_default_file (const gchar *filename);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-void gtk_rc_set_default_files (gchar **filenames);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-gchar** gtk_rc_get_default_files (void);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-GtkStyle* gtk_rc_get_style (GtkWidget *widget);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-GtkStyle* gtk_rc_get_style_by_paths (GtkSettings *settings,
- const char *widget_path,
- const char *class_path,
- GType type);
-
-GDK_DEPRECATED_FOR(GtkStyleContext)
-gboolean gtk_rc_reparse_all_for_settings (GtkSettings *settings,
- gboolean force_load);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-void gtk_rc_reset_styles (GtkSettings *settings);
-
-GDK_DEPRECATED_FOR(GtkStyleContext)
-gchar* gtk_rc_find_pixmap_in_path (GtkSettings *settings,
- GScanner *scanner,
- const gchar *pixmap_file);
-
-GDK_DEPRECATED_FOR(GtkStyleContext)
-void gtk_rc_parse (const gchar *filename);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-void gtk_rc_parse_string (const gchar *rc_string);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-gboolean gtk_rc_reparse_all (void);
-
-GType gtk_rc_style_get_type (void) G_GNUC_CONST;
-GDK_DEPRECATED_FOR(GtkStyleContext)
-GtkRcStyle* gtk_rc_style_new (void);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-GtkRcStyle* gtk_rc_style_copy (GtkRcStyle *orig);
-
-GDK_DEPRECATED_FOR(GtkStyleContext)
-gchar* gtk_rc_find_module_in_path (const gchar *module_file);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-gchar* gtk_rc_get_theme_dir (void);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-gchar* gtk_rc_get_module_dir (void);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-gchar* gtk_rc_get_im_module_path (void);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-gchar* gtk_rc_get_im_module_file (void);
-
-/* private functions/definitions */
-
-/**
- * GtkRcTokenType:
- * @GTK_RC_TOKEN_INVALID:
- * @GTK_RC_TOKEN_INCLUDE:
- * @GTK_RC_TOKEN_NORMAL:
- * @GTK_RC_TOKEN_ACTIVE:
- * @GTK_RC_TOKEN_PRELIGHT:
- * @GTK_RC_TOKEN_SELECTED:
- * @GTK_RC_TOKEN_INSENSITIVE:
- * @GTK_RC_TOKEN_FG:
- * @GTK_RC_TOKEN_BG:
- * @GTK_RC_TOKEN_TEXT:
- * @GTK_RC_TOKEN_BASE:
- * @GTK_RC_TOKEN_XTHICKNESS:
- * @GTK_RC_TOKEN_YTHICKNESS:
- * @GTK_RC_TOKEN_FONT:
- * @GTK_RC_TOKEN_FONTSET:
- * @GTK_RC_TOKEN_FONT_NAME:
- * @GTK_RC_TOKEN_BG_PIXMAP:
- * @GTK_RC_TOKEN_PIXMAP_PATH:
- * @GTK_RC_TOKEN_STYLE:
- * @GTK_RC_TOKEN_BINDING:
- * @GTK_RC_TOKEN_BIND:
- * @GTK_RC_TOKEN_WIDGET:
- * @GTK_RC_TOKEN_WIDGET_CLASS:
- * @GTK_RC_TOKEN_CLASS:
- * @GTK_RC_TOKEN_LOWEST:
- * @GTK_RC_TOKEN_GTK:
- * @GTK_RC_TOKEN_APPLICATION:
- * @GTK_RC_TOKEN_THEME:
- * @GTK_RC_TOKEN_RC:
- * @GTK_RC_TOKEN_HIGHEST:
- * @GTK_RC_TOKEN_ENGINE:
- * @GTK_RC_TOKEN_MODULE_PATH:
- * @GTK_RC_TOKEN_IM_MODULE_PATH:
- * @GTK_RC_TOKEN_IM_MODULE_FILE:
- * @GTK_RC_TOKEN_STOCK:
- * @GTK_RC_TOKEN_LTR:
- * @GTK_RC_TOKEN_RTL:
- * @GTK_RC_TOKEN_COLOR:
- * @GTK_RC_TOKEN_UNBIND:
- * @GTK_RC_TOKEN_LAST:
- *
- * The #GtkRcTokenType enumeration represents the tokens
- * in the RC file. It is exposed so that theme engines
- * can reuse these tokens when parsing the theme-engine
- * specific portions of a RC file.
- *
- * Deprecated: 3.0: Use #GtkCssProvider instead.
- */
-typedef enum {
- GTK_RC_TOKEN_INVALID = G_TOKEN_LAST,
- GTK_RC_TOKEN_INCLUDE,
- GTK_RC_TOKEN_NORMAL,
- GTK_RC_TOKEN_ACTIVE,
- GTK_RC_TOKEN_PRELIGHT,
- GTK_RC_TOKEN_SELECTED,
- GTK_RC_TOKEN_INSENSITIVE,
- GTK_RC_TOKEN_FG,
- GTK_RC_TOKEN_BG,
- GTK_RC_TOKEN_TEXT,
- GTK_RC_TOKEN_BASE,
- GTK_RC_TOKEN_XTHICKNESS,
- GTK_RC_TOKEN_YTHICKNESS,
- GTK_RC_TOKEN_FONT,
- GTK_RC_TOKEN_FONTSET,
- GTK_RC_TOKEN_FONT_NAME,
- GTK_RC_TOKEN_BG_PIXMAP,
- GTK_RC_TOKEN_PIXMAP_PATH,
- GTK_RC_TOKEN_STYLE,
- GTK_RC_TOKEN_BINDING,
- GTK_RC_TOKEN_BIND,
- GTK_RC_TOKEN_WIDGET,
- GTK_RC_TOKEN_WIDGET_CLASS,
- GTK_RC_TOKEN_CLASS,
- GTK_RC_TOKEN_LOWEST,
- GTK_RC_TOKEN_GTK,
- GTK_RC_TOKEN_APPLICATION,
- GTK_RC_TOKEN_THEME,
- GTK_RC_TOKEN_RC,
- GTK_RC_TOKEN_HIGHEST,
- GTK_RC_TOKEN_ENGINE,
- GTK_RC_TOKEN_MODULE_PATH,
- GTK_RC_TOKEN_IM_MODULE_PATH,
- GTK_RC_TOKEN_IM_MODULE_FILE,
- GTK_RC_TOKEN_STOCK,
- GTK_RC_TOKEN_LTR,
- GTK_RC_TOKEN_RTL,
- GTK_RC_TOKEN_COLOR,
- GTK_RC_TOKEN_UNBIND,
- GTK_RC_TOKEN_LAST
-} GtkRcTokenType;
-
-GDK_DEPRECATED_FOR(GtkStyleContext)
-GScanner* gtk_rc_scanner_new (void);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-guint gtk_rc_parse_color (GScanner *scanner,
- GdkColor *color);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-guint gtk_rc_parse_color_full (GScanner *scanner,
- GtkRcStyle *style,
- GdkColor *color);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-guint gtk_rc_parse_state (GScanner *scanner,
- GtkStateType *state);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-guint gtk_rc_parse_priority (GScanner *scanner,
- GtkPathPriorityType *priority);
-
-#endif
-
-/* rc properties
- * (structure forward declared in gtkstyle.h)
- */
-struct _GtkRcProperty
-{
- /* quark-ified property identifier like "GtkScrollbar::spacing" */
- GQuark type_name;
- GQuark property_name;
-
- /* fields similar to GtkSettingsValue */
- gchar *origin;
- GValue value;
-};
-
-G_END_DECLS
-
-#endif /* __GTK_RC_H__ */
#include <string.h>
+#include "gtksettings.h"
+
#include "gtkmodules.h"
#include "gtkmodulesprivate.h"
#include "gtksettingsprivate.h"
#include "quartz/gdkquartz.h"
#endif
+#include "deprecated/gtkrc.h"
+
/**
* SECTION:gtksettings
#ifndef __GTK_SETTINGS_H__
#define __GTK_SETTINGS_H__
-#include <gtk/gtkrc.h>
+#include <gdk/gdk.h>
G_BEGIN_DECLS
/* --- typedefs --- */
+typedef struct _GtkSettings GtkSettings;
typedef struct _GtkSettingsPrivate GtkSettingsPrivate;
typedef struct _GtkSettingsClass GtkSettingsClass;
typedef struct _GtkSettingsValue GtkSettingsValue;
+typedef gboolean (*GtkRcPropertyParser) (const GParamSpec *pspec,
+ const GString *rc_string,
+ GValue *property_value);
+
+
/* --- structures --- */
struct _GtkSettings
{
#include "gtkdnd.h"
#include "gtkdebug.h"
#include "gtkintl.h"
+#include "gtkmain.h"
#include "gtkwidgetprivate.h"
#include <gdk/gdkx.h>
#ifndef __GTK_SOCKET_H__
#define __GTK_SOCKET_H__
-#include <gtk/gtk.h>
+#include <gdk/gdk.h>
+#include <gtk/gtkwindow.h>
#ifdef GDK_WINDOWING_X11
+++ /dev/null
-/* GTK - The GIMP Toolkit
- * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
- */
-
-/*
- * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
- * file for a list of people on the GTK+ Team. See the ChangeLog
- * files for a list of changes. These files are distributed with
- * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
- */
-
-#include "config.h"
-#include <math.h>
-#include <stdlib.h>
-#include <string.h>
-#include <gobject/gvaluecollector.h>
-#include "gtkmarshalers.h"
-#include "gtkpango.h"
-#include "gtkrc.h"
-#include "gtkspinbutton.h"
-#include "gtkstyle.h"
-#include "gtkstylecontextprivate.h"
-#include "gtkwidget.h"
-#include "gtkiconfactory.h"
-#include "gtkintl.h"
-#include "gtkdebug.h"
-#include "gtkspinner.h"
-#include "gtkborder.h"
-
-/**
- * SECTION:gtkstyle
- * @Short_description: Deprecated object that holds style information
- * for widgets
- * @Title: GtkStyle
- *
- * A #GtkStyle object encapsulates the information that provides the look and
- * feel for a widget.
- *
- * <warning>
- * In GTK+ 3.0, GtkStyle has been deprecated and replaced by #GtkStyleContext.
- * </warning>
- *
- * Each #GtkWidget has an associated #GtkStyle object that is used when
- * rendering that widget. Also, a #GtkStyle holds information for the five
- * possible widget states though not every widget supports all five
- * states; see #GtkStateType.
- *
- * Usually the #GtkStyle for a widget is the same as the default style that
- * is set by GTK+ and modified the theme engine.
- *
- * Usually applications should not need to use or modify the #GtkStyle of
- * their widgets.
- */
-
-
-#define LIGHTNESS_MULT 1.3
-#define DARKNESS_MULT 0.7
-
-/* --- typedefs & structures --- */
-typedef struct {
- GType widget_type;
- GParamSpec *pspec;
- GValue value;
-} PropertyValue;
-
-#define GTK_STYLE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_STYLE, GtkStylePrivate))
-
-typedef struct _GtkStylePrivate GtkStylePrivate;
-
-struct _GtkStylePrivate {
- GtkStyleContext *context;
- gulong context_changed_id;
-};
-
-enum {
- PROP_0,
- PROP_CONTEXT
-};
-
-/* --- prototypes --- */
-static void gtk_style_finalize (GObject *object);
-static void gtk_style_constructed (GObject *object);
-static void gtk_style_set_property (GObject *object,
- guint prop_id,
- const GValue *value,
- GParamSpec *pspec);
-static void gtk_style_get_property (GObject *object,
- guint prop_id,
- GValue *value,
- GParamSpec *pspec);
-
-static void gtk_style_real_realize (GtkStyle *style);
-static void gtk_style_real_unrealize (GtkStyle *style);
-static void gtk_style_real_copy (GtkStyle *style,
- GtkStyle *src);
-static void gtk_style_real_set_background (GtkStyle *style,
- GdkWindow *window,
- GtkStateType state_type);
-static GtkStyle *gtk_style_real_clone (GtkStyle *style);
-static void gtk_style_real_init_from_rc (GtkStyle *style,
- GtkRcStyle *rc_style);
-static GdkPixbuf *gtk_default_render_icon (GtkStyle *style,
- const GtkIconSource *source,
- GtkTextDirection direction,
- GtkStateType state,
- GtkIconSize size,
- GtkWidget *widget,
- const gchar *detail);
-static void gtk_default_draw_hline (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x1,
- gint x2,
- gint y);
-static void gtk_default_draw_vline (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkWidget *widget,
- const gchar *detail,
- gint y1,
- gint y2,
- gint x);
-static void gtk_default_draw_shadow (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height);
-static void gtk_default_draw_arrow (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- GtkArrowType arrow_type,
- gboolean fill,
- gint x,
- gint y,
- gint width,
- gint height);
-static void gtk_default_draw_diamond (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height);
-static void gtk_default_draw_box (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height);
-static void gtk_default_draw_flat_box (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height);
-static void gtk_default_draw_check (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height);
-static void gtk_default_draw_option (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height);
-static void gtk_default_draw_tab (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height);
-static void gtk_default_draw_shadow_gap (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height,
- GtkPositionType gap_side,
- gint gap_x,
- gint gap_width);
-static void gtk_default_draw_box_gap (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height,
- GtkPositionType gap_side,
- gint gap_x,
- gint gap_width);
-static void gtk_default_draw_extension (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height,
- GtkPositionType gap_side);
-static void gtk_default_draw_focus (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height);
-static void gtk_default_draw_slider (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height,
- GtkOrientation orientation);
-static void gtk_default_draw_handle (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height,
- GtkOrientation orientation);
-static void gtk_default_draw_expander (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- GtkExpanderStyle expander_style);
-static void gtk_default_draw_layout (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- gboolean use_text,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- PangoLayout *layout);
-static void gtk_default_draw_resize_grip (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkWidget *widget,
- const gchar *detail,
- GdkWindowEdge edge,
- gint x,
- gint y,
- gint width,
- gint height);
-static void gtk_default_draw_spinner (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkWidget *widget,
- const gchar *detail,
- guint step,
- gint x,
- gint y,
- gint width,
- gint height);
-
-static void rgb_to_hls (gdouble *r,
- gdouble *g,
- gdouble *b);
-static void hls_to_rgb (gdouble *h,
- gdouble *l,
- gdouble *s);
-
-static void transform_detail_string (const gchar *detail,
- GtkStyleContext *context);
-
-/*
- * Data for default check and radio buttons
- */
-
-static const GtkRequisition default_option_indicator_size = { 7, 13 };
-static const GtkBorder default_option_indicator_spacing = { 7, 5, 2, 2 };
-
-#define GTK_GRAY 0xdcdc, 0xdada, 0xd5d5
-#define GTK_DARK_GRAY 0xc4c4, 0xc2c2, 0xbdbd
-#define GTK_LIGHT_GRAY 0xeeee, 0xebeb, 0xe7e7
-#define GTK_WHITE 0xffff, 0xffff, 0xffff
-#define GTK_BLUE 0x4b4b, 0x6969, 0x8383
-#define GTK_VERY_DARK_GRAY 0x9c9c, 0x9a9a, 0x9494
-#define GTK_BLACK 0x0000, 0x0000, 0x0000
-#define GTK_WEAK_GRAY 0x7530, 0x7530, 0x7530
-
-/* --- variables --- */
-static const GdkColor gtk_default_normal_fg = { 0, GTK_BLACK };
-static const GdkColor gtk_default_active_fg = { 0, GTK_BLACK };
-static const GdkColor gtk_default_prelight_fg = { 0, GTK_BLACK };
-static const GdkColor gtk_default_selected_fg = { 0, GTK_WHITE };
-static const GdkColor gtk_default_insensitive_fg = { 0, GTK_WEAK_GRAY };
-
-static const GdkColor gtk_default_normal_bg = { 0, GTK_GRAY };
-static const GdkColor gtk_default_active_bg = { 0, GTK_DARK_GRAY };
-static const GdkColor gtk_default_prelight_bg = { 0, GTK_LIGHT_GRAY };
-static const GdkColor gtk_default_selected_bg = { 0, GTK_BLUE };
-static const GdkColor gtk_default_insensitive_bg = { 0, GTK_GRAY };
-static const GdkColor gtk_default_selected_base = { 0, GTK_BLUE };
-static const GdkColor gtk_default_active_base = { 0, GTK_VERY_DARK_GRAY };
-
-/* --- signals --- */
-static guint realize_signal = 0;
-static guint unrealize_signal = 0;
-
-G_DEFINE_TYPE (GtkStyle, gtk_style, G_TYPE_OBJECT)
-
-/* --- functions --- */
-
-static void
-gtk_style_init (GtkStyle *style)
-{
- gint i;
-
- style->font_desc = pango_font_description_from_string ("Sans 10");
-
- style->attach_count = 0;
-
- style->black.red = 0;
- style->black.green = 0;
- style->black.blue = 0;
-
- style->white.red = 65535;
- style->white.green = 65535;
- style->white.blue = 65535;
-
- style->fg[GTK_STATE_NORMAL] = gtk_default_normal_fg;
- style->fg[GTK_STATE_ACTIVE] = gtk_default_active_fg;
- style->fg[GTK_STATE_PRELIGHT] = gtk_default_prelight_fg;
- style->fg[GTK_STATE_SELECTED] = gtk_default_selected_fg;
- style->fg[GTK_STATE_INSENSITIVE] = gtk_default_insensitive_fg;
-
- style->bg[GTK_STATE_NORMAL] = gtk_default_normal_bg;
- style->bg[GTK_STATE_ACTIVE] = gtk_default_active_bg;
- style->bg[GTK_STATE_PRELIGHT] = gtk_default_prelight_bg;
- style->bg[GTK_STATE_SELECTED] = gtk_default_selected_bg;
- style->bg[GTK_STATE_INSENSITIVE] = gtk_default_insensitive_bg;
-
- for (i = 0; i < 4; i++)
- {
- style->text[i] = style->fg[i];
- style->base[i] = style->white;
- }
-
- style->base[GTK_STATE_SELECTED] = gtk_default_selected_base;
- style->text[GTK_STATE_SELECTED] = style->white;
- style->base[GTK_STATE_ACTIVE] = gtk_default_active_base;
- style->text[GTK_STATE_ACTIVE] = style->white;
- style->base[GTK_STATE_INSENSITIVE] = gtk_default_prelight_bg;
- style->text[GTK_STATE_INSENSITIVE] = gtk_default_insensitive_fg;
-
- style->rc_style = NULL;
-
- style->xthickness = 2;
- style->ythickness = 2;
-
- style->property_cache = NULL;
-}
-
-static void
-gtk_style_class_init (GtkStyleClass *klass)
-{
- GObjectClass *object_class = G_OBJECT_CLASS (klass);
-
- object_class->finalize = gtk_style_finalize;
- object_class->set_property = gtk_style_set_property;
- object_class->get_property = gtk_style_get_property;
- object_class->constructed = gtk_style_constructed;
-
- klass->clone = gtk_style_real_clone;
- klass->copy = gtk_style_real_copy;
- klass->init_from_rc = gtk_style_real_init_from_rc;
- klass->realize = gtk_style_real_realize;
- klass->unrealize = gtk_style_real_unrealize;
- klass->set_background = gtk_style_real_set_background;
- klass->render_icon = gtk_default_render_icon;
-
- klass->draw_hline = gtk_default_draw_hline;
- klass->draw_vline = gtk_default_draw_vline;
- klass->draw_shadow = gtk_default_draw_shadow;
- klass->draw_arrow = gtk_default_draw_arrow;
- klass->draw_diamond = gtk_default_draw_diamond;
- klass->draw_box = gtk_default_draw_box;
- klass->draw_flat_box = gtk_default_draw_flat_box;
- klass->draw_check = gtk_default_draw_check;
- klass->draw_option = gtk_default_draw_option;
- klass->draw_tab = gtk_default_draw_tab;
- klass->draw_shadow_gap = gtk_default_draw_shadow_gap;
- klass->draw_box_gap = gtk_default_draw_box_gap;
- klass->draw_extension = gtk_default_draw_extension;
- klass->draw_focus = gtk_default_draw_focus;
- klass->draw_slider = gtk_default_draw_slider;
- klass->draw_handle = gtk_default_draw_handle;
- klass->draw_expander = gtk_default_draw_expander;
- klass->draw_layout = gtk_default_draw_layout;
- klass->draw_resize_grip = gtk_default_draw_resize_grip;
- klass->draw_spinner = gtk_default_draw_spinner;
-
- g_type_class_add_private (object_class, sizeof (GtkStylePrivate));
-
- g_object_class_install_property (object_class,
- PROP_CONTEXT,
- g_param_spec_object ("context",
- P_("Style context"),
- P_("GtkStyleContext to get style from"),
- GTK_TYPE_STYLE_CONTEXT,
- G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
-
- /**
- * GtkStyle::realize:
- * @style: the object which received the signal
- *
- * Emitted when the style has been initialized for a particular
- * visual. Connecting to this signal is probably seldom
- * useful since most of the time applications and widgets only
- * deal with styles that have been already realized.
- *
- * Since: 2.4
- */
- realize_signal = g_signal_new (I_("realize"),
- G_TYPE_FROM_CLASS (object_class),
- G_SIGNAL_RUN_FIRST,
- G_STRUCT_OFFSET (GtkStyleClass, realize),
- NULL, NULL,
- _gtk_marshal_VOID__VOID,
- G_TYPE_NONE, 0);
- /**
- * GtkStyle::unrealize:
- * @style: the object which received the signal
- *
- * Emitted when the aspects of the style specific to a particular visual
- * is being cleaned up. A connection to this signal can be useful
- * if a widget wants to cache objects as object data on #GtkStyle.
- * This signal provides a convenient place to free such cached objects.
- *
- * Since: 2.4
- */
- unrealize_signal = g_signal_new (I_("unrealize"),
- G_TYPE_FROM_CLASS (object_class),
- G_SIGNAL_RUN_FIRST,
- G_STRUCT_OFFSET (GtkStyleClass, unrealize),
- NULL, NULL,
- _gtk_marshal_VOID__VOID,
- G_TYPE_NONE, 0);
-}
-
-static void
-gtk_style_finalize (GObject *object)
-{
- GtkStyle *style = GTK_STYLE (object);
- GtkStylePrivate *priv = GTK_STYLE_GET_PRIVATE (style);
- gint i;
-
- g_return_if_fail (style->attach_count == 0);
-
- /* All the styles in the list have the same
- * style->styles pointer. If we delete the
- * *first* style from the list, we need to update
- * the style->styles pointers from all the styles.
- * Otherwise we simply remove the node from
- * the list.
- */
- if (style->styles)
- {
- if (style->styles->data != style)
- style->styles = g_slist_remove (style->styles, style);
- else
- {
- GSList *tmp_list = style->styles->next;
-
- while (tmp_list)
- {
- GTK_STYLE (tmp_list->data)->styles = style->styles->next;
- tmp_list = tmp_list->next;
- }
- g_slist_free_1 (style->styles);
- }
- }
-
- g_slist_foreach (style->icon_factories, (GFunc) g_object_unref, NULL);
- g_slist_free (style->icon_factories);
-
- pango_font_description_free (style->font_desc);
-
- if (style->private_font_desc)
- pango_font_description_free (style->private_font_desc);
-
- if (style->rc_style)
- g_object_unref (style->rc_style);
-
- if (priv->context)
- {
- if (priv->context_changed_id)
- g_signal_handler_disconnect (priv->context, priv->context_changed_id);
-
- g_object_unref (priv->context);
- }
-
- for (i = 0; i < 5; i++)
- {
- if (style->background[i])
- cairo_pattern_destroy (style->background[i]);
- }
-
- G_OBJECT_CLASS (gtk_style_parent_class)->finalize (object);
-}
-
-static void
-gtk_style_set_property (GObject *object,
- guint prop_id,
- const GValue *value,
- GParamSpec *pspec)
-{
- GtkStylePrivate *priv;
-
- priv = GTK_STYLE_GET_PRIVATE (object);
-
- switch (prop_id)
- {
- case PROP_CONTEXT:
- priv->context = g_value_dup_object (value);
- break;
- default:
- G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
- break;
- }
-}
-
-static void
-gtk_style_get_property (GObject *object,
- guint prop_id,
- GValue *value,
- GParamSpec *pspec)
-{
- GtkStylePrivate *priv;
-
- priv = GTK_STYLE_GET_PRIVATE (object);
-
- switch (prop_id)
- {
- case PROP_CONTEXT:
- g_value_set_object (value, priv->context);
- break;
- default:
- G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
- break;
- }
-}
-
-static void
-set_color (GtkStyle *style,
- GtkStyleContext *context,
- GtkStateType state,
- GtkRcFlags prop)
-{
- GtkStateFlags flags;
- GdkRGBA *color = NULL;
- GdkColor *dest = { 0 }; /* Shut up gcc */
-
- switch (state)
- {
- case GTK_STATE_ACTIVE:
- flags = GTK_STATE_FLAG_ACTIVE;
- break;
- case GTK_STATE_PRELIGHT:
- flags = GTK_STATE_FLAG_PRELIGHT;
- break;
- case GTK_STATE_SELECTED:
- flags = GTK_STATE_FLAG_SELECTED;
- break;
- case GTK_STATE_INSENSITIVE:
- flags = GTK_STATE_FLAG_INSENSITIVE;
- break;
- default:
- flags = 0;
- }
-
- switch (prop)
- {
- case GTK_RC_BG:
- gtk_style_context_get (context, flags,
- "background-color", &color,
- NULL);
- dest = &style->bg[state];
- break;
- case GTK_RC_FG:
- gtk_style_context_get (context, flags,
- "color", &color,
- NULL);
- dest = &style->fg[state];
- break;
- case GTK_RC_TEXT:
- gtk_style_context_get (context, flags,
- "color", &color,
- NULL);
- dest = &style->text[state];
- break;
- case GTK_RC_BASE:
- gtk_style_context_get (context, flags,
- "background-color", &color,
- NULL);
- dest = &style->base[state];
- break;
- }
-
- if (color)
- {
- dest->pixel = 0;
- dest->red = CLAMP ((guint) (color->red * 65535), 0, 65535);
- dest->green = CLAMP ((guint) (color->green * 65535), 0, 65535);
- dest->blue = CLAMP ((guint) (color->blue * 65535), 0, 65535);
- gdk_rgba_free (color);
- }
-}
-
-static void
-gtk_style_update_from_context (GtkStyle *style)
-{
- GtkStylePrivate *priv;
- GtkStateType state;
- GtkBorder padding;
- gint i;
-
- priv = GTK_STYLE_GET_PRIVATE (style);
-
- for (state = GTK_STATE_NORMAL; state <= GTK_STATE_INSENSITIVE; state++)
- {
- if (gtk_style_context_has_class (priv->context, "entry"))
- {
- gtk_style_context_save (priv->context);
- gtk_style_context_remove_class (priv->context, "entry");
- set_color (style, priv->context, state, GTK_RC_BG);
- set_color (style, priv->context, state, GTK_RC_FG);
- gtk_style_context_restore (priv->context);
-
- set_color (style, priv->context, state, GTK_RC_BASE);
- set_color (style, priv->context, state, GTK_RC_TEXT);
- }
- else
- {
- gtk_style_context_save (priv->context);
- gtk_style_context_add_class (priv->context, "entry");
- set_color (style, priv->context, state, GTK_RC_BASE);
- set_color (style, priv->context, state, GTK_RC_TEXT);
- gtk_style_context_restore (priv->context);
-
- set_color (style, priv->context, state, GTK_RC_BG);
- set_color (style, priv->context, state, GTK_RC_FG);
- }
- }
-
- if (style->font_desc)
- pango_font_description_free (style->font_desc);
-
- gtk_style_context_get (priv->context, 0,
- "font", &style->font_desc,
- NULL);
- gtk_style_context_get_padding (priv->context, 0, &padding);
-
- style->xthickness = padding.left;
- style->ythickness = padding.top;
-
- for (i = 0; i < 5; i++)
- {
- _gtk_style_shade (&style->bg[i], &style->light[i], LIGHTNESS_MULT);
- _gtk_style_shade (&style->bg[i], &style->dark[i], DARKNESS_MULT);
-
- style->mid[i].red = (style->light[i].red + style->dark[i].red) / 2;
- style->mid[i].green = (style->light[i].green + style->dark[i].green) / 2;
- style->mid[i].blue = (style->light[i].blue + style->dark[i].blue) / 2;
-
- style->text_aa[i].red = (style->text[i].red + style->base[i].red) / 2;
- style->text_aa[i].green = (style->text[i].green + style->base[i].green) / 2;
- style->text_aa[i].blue = (style->text[i].blue + style->base[i].blue) / 2;
- }
-
- style->black.red = 0x0000;
- style->black.green = 0x0000;
- style->black.blue = 0x0000;
-
- style->white.red = 0xffff;
- style->white.green = 0xffff;
- style->white.blue = 0xffff;
-
- for (i = 0; i < 5; i++)
- {
- if (style->background[i])
- cairo_pattern_destroy (style->background[i]);
-
- style->background[i] = cairo_pattern_create_rgb (style->bg[i].red / 65535.0,
- style->bg[i].green / 65535.0,
- style->bg[i].blue / 65535.0);
- }
-}
-
-static void
-style_context_changed (GtkStyleContext *context,
- gpointer user_data)
-{
- gtk_style_update_from_context (GTK_STYLE (user_data));
-}
-
-static void
-gtk_style_constructed (GObject *object)
-{
- GtkStylePrivate *priv;
-
- priv = GTK_STYLE_GET_PRIVATE (object);
-
- if (priv->context)
- {
- gtk_style_update_from_context (GTK_STYLE (object));
-
- priv->context_changed_id = g_signal_connect (priv->context, "changed",
- G_CALLBACK (style_context_changed), object);
- }
-}
-
-/**
- * gtk_style_copy:
- * @style: a #GtkStyle
- *
- * Creates a copy of the passed in #GtkStyle object.
- *
- * Returns: (transfer full): a copy of @style
- *
- * Deprecated:3.0: Use #GtkStyleContext instead
- */
-GtkStyle*
-gtk_style_copy (GtkStyle *style)
-{
- GtkStyle *new_style;
-
- g_return_val_if_fail (GTK_IS_STYLE (style), NULL);
-
- new_style = GTK_STYLE_GET_CLASS (style)->clone (style);
- GTK_STYLE_GET_CLASS (style)->copy (new_style, style);
-
- return new_style;
-}
-
-GtkStyle*
-_gtk_style_new_for_path (GdkScreen *screen,
- GtkWidgetPath *path)
-{
- GtkStyleContext *context;
- GtkStyle *style;
-
- context = gtk_style_context_new ();
-
- if (screen)
- gtk_style_context_set_screen (context, screen);
-
- gtk_style_context_set_path (context, path);
-
- style = g_object_new (GTK_TYPE_STYLE,
- "context", context,
- NULL);
-
- g_object_unref (context);
-
- return style;
-}
-
-/**
- * gtk_style_new:
- *
- * Creates a new #GtkStyle.
- *
- * Returns: a new #GtkStyle.
- *
- * Deprecated: 3.0: Use #GtkStyleContext
- */
-GtkStyle*
-gtk_style_new (void)
-{
- GtkWidgetPath *path;
- GtkStyle *style;
-
- path = gtk_widget_path_new ();
- gtk_widget_path_append_type (path, GTK_TYPE_WIDGET);
-
- style = _gtk_style_new_for_path (gdk_screen_get_default (), path);
-
- gtk_widget_path_free (path);
-
- return style;
-}
-
-/**
- * gtk_style_has_context:
- * @style: a #GtkStyle
- *
- * Returns whether @style has an associated #GtkStyleContext.
- *
- * Returns: %TRUE if @style has a #GtkStyleContext
- *
- * Since: 3.0
- */
-gboolean
-gtk_style_has_context (GtkStyle *style)
-{
- GtkStylePrivate *priv;
-
- priv = GTK_STYLE_GET_PRIVATE (style);
-
- return priv->context != NULL;
-}
-
-/**
- * gtk_style_attach: (skip)
- * @style: a #GtkStyle.
- * @window: a #GdkWindow.
- *
- * Attaches a style to a window; this process allocates the
- * colors and creates the GC's for the style - it specializes
- * it to a particular visual. The process may involve the creation
- * of a new style if the style has already been attached to a
- * window with a different style and visual.
- *
- * Since this function may return a new object, you have to use it
- * in the following way:
- * <literal>style = gtk_style_attach (style, window)</literal>
- *
- * Returns: Either @style, or a newly-created #GtkStyle.
- * If the style is newly created, the style parameter
- * will be unref'ed, and the new style will have
- * a reference count belonging to the caller.
- *
- * Deprecated:3.0: Use gtk_widget_style_attach() instead
- */
-GtkStyle*
-gtk_style_attach (GtkStyle *style,
- GdkWindow *window)
-{
- g_return_val_if_fail (GTK_IS_STYLE (style), NULL);
- g_return_val_if_fail (window != NULL, NULL);
-
- return style;
-}
-
-/**
- * gtk_style_detach:
- * @style: a #GtkStyle
- *
- * Detaches a style from a window. If the style is not attached
- * to any windows anymore, it is unrealized. See gtk_style_attach().
- *
- * Deprecated:3.0: Use #GtkStyleContext instead
- */
-void
-gtk_style_detach (GtkStyle *style)
-{
- g_return_if_fail (GTK_IS_STYLE (style));
-}
-
-/**
- * gtk_style_lookup_icon_set:
- * @style: a #GtkStyle
- * @stock_id: an icon name
- *
- * Looks up @stock_id in the icon factories associated with @style
- * and the default icon factory, returning an icon set if found,
- * otherwise %NULL.
- *
- * Return value: (transfer none): icon set of @stock_id
- *
- * Deprecated:3.0: Use gtk_style_context_lookup_icon_set() instead
- */
-GtkIconSet*
-gtk_style_lookup_icon_set (GtkStyle *style,
- const char *stock_id)
-{
- GtkStylePrivate *priv;
-
- g_return_val_if_fail (GTK_IS_STYLE (style), NULL);
- g_return_val_if_fail (stock_id != NULL, NULL);
-
- priv = GTK_STYLE_GET_PRIVATE (style);
-
- if (priv->context)
- return gtk_style_context_lookup_icon_set (priv->context, stock_id);
-
- return gtk_icon_factory_lookup_default (stock_id);
-}
-
-/**
- * gtk_style_lookup_color:
- * @style: a #GtkStyle
- * @color_name: the name of the logical color to look up
- * @color: (out): the #GdkColor to fill in
- *
- * Looks up @color_name in the style's logical color mappings,
- * filling in @color and returning %TRUE if found, otherwise
- * returning %FALSE. Do not cache the found mapping, because
- * it depends on the #GtkStyle and might change when a theme
- * switch occurs.
- *
- * Return value: %TRUE if the mapping was found.
- *
- * Since: 2.10
- *
- * Deprecated:3.0: Use gtk_style_context_lookup_color() instead
- **/
-gboolean
-gtk_style_lookup_color (GtkStyle *style,
- const char *color_name,
- GdkColor *color)
-{
- GtkStylePrivate *priv;
- gboolean result;
- GdkRGBA rgba;
-
- g_return_val_if_fail (GTK_IS_STYLE (style), FALSE);
- g_return_val_if_fail (color_name != NULL, FALSE);
- g_return_val_if_fail (color != NULL, FALSE);
-
- priv = GTK_STYLE_GET_PRIVATE (style);
-
- if (!priv->context)
- return FALSE;
-
- result = gtk_style_context_lookup_color (priv->context, color_name, &rgba);
-
- if (color)
- {
- color->red = (guint16) (rgba.red * 65535);
- color->green = (guint16) (rgba.green * 65535);
- color->blue = (guint16) (rgba.blue * 65535);
- color->pixel = 0;
- }
-
- return result;
-}
-
-/**
- * gtk_style_set_background:
- * @style: a #GtkStyle
- * @window: a #GdkWindow
- * @state_type: a state
- *
- * Sets the background of @window to the background color or pixmap
- * specified by @style for the given state.
- *
- * Deprecated:3.0: Use gtk_style_context_set_background() instead
- */
-void
-gtk_style_set_background (GtkStyle *style,
- GdkWindow *window,
- GtkStateType state_type)
-{
- g_return_if_fail (GTK_IS_STYLE (style));
- g_return_if_fail (window != NULL);
-
- GTK_STYLE_GET_CLASS (style)->set_background (style, window, state_type);
-}
-
-/* Default functions */
-static GtkStyle *
-gtk_style_real_clone (GtkStyle *style)
-{
- GtkStylePrivate *priv;
-
- priv = GTK_STYLE_GET_PRIVATE (style);
-
- return g_object_new (G_OBJECT_TYPE (style),
- "context", priv->context,
- NULL);
-}
-
-static void
-gtk_style_real_copy (GtkStyle *style,
- GtkStyle *src)
-{
- gint i;
-
- for (i = 0; i < 5; i++)
- {
- style->fg[i] = src->fg[i];
- style->bg[i] = src->bg[i];
- style->text[i] = src->text[i];
- style->base[i] = src->base[i];
-
- if (style->background[i])
- cairo_pattern_destroy (style->background[i]),
- style->background[i] = src->background[i];
- if (style->background[i])
- cairo_pattern_reference (style->background[i]);
- }
-
- if (style->font_desc)
- pango_font_description_free (style->font_desc);
- if (src->font_desc)
- style->font_desc = pango_font_description_copy (src->font_desc);
- else
- style->font_desc = NULL;
-
- style->xthickness = src->xthickness;
- style->ythickness = src->ythickness;
-
- if (style->rc_style)
- g_object_unref (style->rc_style);
- style->rc_style = src->rc_style;
- if (src->rc_style)
- g_object_ref (src->rc_style);
-
- g_slist_foreach (style->icon_factories, (GFunc) g_object_unref, NULL);
- g_slist_free (style->icon_factories);
- style->icon_factories = g_slist_copy (src->icon_factories);
- g_slist_foreach (style->icon_factories, (GFunc) g_object_ref, NULL);
-}
-
-static void
-gtk_style_real_init_from_rc (GtkStyle *style,
- GtkRcStyle *rc_style)
-{
-}
-
-/**
- * gtk_style_get_style_property:
- * @style: a #GtkStyle
- * @widget_type: the #GType of a descendant of #GtkWidget
- * @property_name: the name of the style property to get
- * @value: a #GValue where the value of the property being
- * queried will be stored
- *
- * Queries the value of a style property corresponding to a
- * widget class is in the given style.
- *
- * Since: 2.16
- */
-void
-gtk_style_get_style_property (GtkStyle *style,
- GType widget_type,
- const gchar *property_name,
- GValue *value)
-{
- GtkStylePrivate *priv;
- GtkWidgetClass *klass;
- GParamSpec *pspec;
- const GValue *peek_value;
-
- klass = g_type_class_ref (widget_type);
- pspec = gtk_widget_class_find_style_property (klass, property_name);
- g_type_class_unref (klass);
-
- if (!pspec)
- {
- g_warning ("%s: widget class `%s' has no property named `%s'",
- G_STRLOC,
- g_type_name (widget_type),
- property_name);
- return;
- }
-
- priv = GTK_STYLE_GET_PRIVATE (style);
- peek_value = _gtk_style_context_peek_style_property (priv->context,
- widget_type,
- 0, pspec);
-
- if (G_VALUE_TYPE (value) == G_PARAM_SPEC_VALUE_TYPE (pspec))
- g_value_copy (peek_value, value);
- else if (g_value_type_transformable (G_PARAM_SPEC_VALUE_TYPE (pspec), G_VALUE_TYPE (value)))
- g_value_transform (peek_value, value);
- else
- g_warning ("can't retrieve style property `%s' of type `%s' as value of type `%s'",
- pspec->name,
- g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)),
- G_VALUE_TYPE_NAME (value));
-}
-
-/**
- * gtk_style_get_valist:
- * @style: a #GtkStyle
- * @widget_type: the #GType of a descendant of #GtkWidget
- * @first_property_name: the name of the first style property to get
- * @var_args: a <type>va_list</type> of pairs of property names and
- * locations to return the property values, starting with the
- * location for @first_property_name.
- *
- * Non-vararg variant of gtk_style_get().
- * Used primarily by language bindings.
- *
- * Since: 2.16
- */
-void
-gtk_style_get_valist (GtkStyle *style,
- GType widget_type,
- const gchar *first_property_name,
- va_list var_args)
-{
- GtkStylePrivate *priv;
- const char *property_name;
- GtkWidgetClass *klass;
-
- g_return_if_fail (GTK_IS_STYLE (style));
-
- klass = g_type_class_ref (widget_type);
-
- priv = GTK_STYLE_GET_PRIVATE (style);
- property_name = first_property_name;
- while (property_name)
- {
- GParamSpec *pspec;
- const GValue *peek_value;
- gchar *error;
-
- pspec = gtk_widget_class_find_style_property (klass, property_name);
-
- if (!pspec)
- {
- g_warning ("%s: widget class `%s' has no property named `%s'",
- G_STRLOC,
- g_type_name (widget_type),
- property_name);
- break;
- }
-
- peek_value = _gtk_style_context_peek_style_property (priv->context, widget_type,
- 0, pspec);
- G_VALUE_LCOPY (peek_value, var_args, 0, &error);
- if (error)
- {
- g_warning ("%s: %s", G_STRLOC, error);
- g_free (error);
- break;
- }
-
- property_name = va_arg (var_args, gchar*);
- }
-
- g_type_class_unref (klass);
-}
-
-/**
- * gtk_style_get:
- * @style: a #GtkStyle
- * @widget_type: the #GType of a descendant of #GtkWidget
- * @first_property_name: the name of the first style property to get
- * @...: pairs of property names and locations to
- * return the property values, starting with the location for
- * @first_property_name, terminated by %NULL.
- *
- * Gets the values of a multiple style properties for @widget_type
- * from @style.
- *
- * Since: 2.16
- */
-void
-gtk_style_get (GtkStyle *style,
- GType widget_type,
- const gchar *first_property_name,
- ...)
-{
- va_list var_args;
-
- va_start (var_args, first_property_name);
- gtk_style_get_valist (style, widget_type, first_property_name, var_args);
- va_end (var_args);
-}
-
-static void
-gtk_style_real_realize (GtkStyle *style)
-{
-}
-
-static void
-gtk_style_real_unrealize (GtkStyle *style)
-{
-}
-
-static void
-gtk_style_real_set_background (GtkStyle *style,
- GdkWindow *window,
- GtkStateType state_type)
-{
- gdk_window_set_background_pattern (window, style->background[state_type]);
-}
-
-/**
- * gtk_style_render_icon:
- * @style: a #GtkStyle
- * @source: the #GtkIconSource specifying the icon to render
- * @direction: a text direction
- * @state: a state
- * @size: (type int): the size to render the icon at. A size of
- * (GtkIconSize)-1 means render at the size of the source and
- * don't scale.
- * @widget: (allow-none): the widget
- * @detail: (allow-none): a style detail
- *
- * Renders the icon specified by @source at the given @size
- * according to the given parameters and returns the result in a
- * pixbuf.
- *
- * Return value: (transfer full): a newly-created #GdkPixbuf
- * containing the rendered icon
- *
- * Deprecated:3.0: Use gtk_render_icon_pixbuf() instead
- */
-GdkPixbuf *
-gtk_style_render_icon (GtkStyle *style,
- const GtkIconSource *source,
- GtkTextDirection direction,
- GtkStateType state,
- GtkIconSize size,
- GtkWidget *widget,
- const gchar *detail)
-{
- GdkPixbuf *pixbuf;
-
- g_return_val_if_fail (GTK_IS_STYLE (style), NULL);
- g_return_val_if_fail (GTK_STYLE_GET_CLASS (style)->render_icon != NULL, NULL);
-
- pixbuf = GTK_STYLE_GET_CLASS (style)->render_icon (style, source, direction, state,
- size, widget, detail);
-
- g_return_val_if_fail (pixbuf != NULL, NULL);
-
- return pixbuf;
-}
-
-/* Default functions */
-
-/**
- * gtk_style_apply_default_background:
- * @style:
- * @cr:
- * @window:
- * @state_type:
- * @x:
- * @y:
- * @width:
- * @height:
- *
- * Deprecated:3.0: Use #GtkStyleContext instead
- */
-void
-gtk_style_apply_default_background (GtkStyle *style,
- cairo_t *cr,
- GdkWindow *window,
- GtkStateType state_type,
- gint x,
- gint y,
- gint width,
- gint height)
-{
- cairo_save (cr);
-
- if (style->background[state_type] == NULL)
- {
- GdkWindow *parent = gdk_window_get_parent (window);
- int x_offset, y_offset;
-
- if (parent)
- {
- gdk_window_get_position (window, &x_offset, &y_offset);
- cairo_translate (cr, -x_offset, -y_offset);
- gtk_style_apply_default_background (style, cr,
- parent, state_type,
- x + x_offset, y + y_offset,
- width, height);
- goto out;
- }
- else
- gdk_cairo_set_source_color (cr, &style->bg[state_type]);
- }
- else
- cairo_set_source (cr, style->background[state_type]);
-
- cairo_rectangle (cr, x, y, width, height);
- cairo_fill (cr);
-
-out:
- cairo_restore (cr);
-}
-
-static GdkPixbuf *
-gtk_default_render_icon (GtkStyle *style,
- const GtkIconSource *source,
- GtkTextDirection direction,
- GtkStateType state,
- GtkIconSize size,
- GtkWidget *widget,
- const gchar *detail)
-{
- GtkStyleContext *context;
- GtkStylePrivate *priv;
- GtkStateFlags flags = 0;
- GdkPixbuf *pixbuf;
-
- if (widget)
- context = gtk_widget_get_style_context (widget);
- else
- {
- priv = GTK_STYLE_GET_PRIVATE (style);
- context = priv->context;
- }
-
- if (!context)
- return NULL;
-
- gtk_style_context_save (context);
-
- if (detail)
- transform_detail_string (detail, context);
-
- switch (state)
- {
- case GTK_STATE_PRELIGHT:
- flags |= GTK_STATE_FLAG_PRELIGHT;
- break;
- case GTK_STATE_INSENSITIVE:
- flags |= GTK_STATE_FLAG_INSENSITIVE;
- break;
- default:
- break;
- }
-
- gtk_style_context_set_state (context, flags);
-
- pixbuf = gtk_render_icon_pixbuf (context, source, size);
-
- gtk_style_context_restore (context);
-
- return pixbuf;
-}
-
-static void
-_cairo_draw_line (cairo_t *cr,
- GdkColor *color,
- gint x1,
- gint y1,
- gint x2,
- gint y2)
-{
- cairo_save (cr);
-
- gdk_cairo_set_source_color (cr, color);
- cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
-
- cairo_move_to (cr, x1 + 0.5, y1 + 0.5);
- cairo_line_to (cr, x2 + 0.5, y2 + 0.5);
- cairo_stroke (cr);
-
- cairo_restore (cr);
-}
-
-static void
-transform_detail_string (const gchar *detail,
- GtkStyleContext *context)
-{
- if (!detail)
- return;
-
- if (strcmp (detail, "arrow") == 0)
- gtk_style_context_add_class (context, "arrow");
- else if (strcmp (detail, "button") == 0)
- gtk_style_context_add_class (context, "button");
- else if (strcmp (detail, "buttondefault") == 0)
- {
- gtk_style_context_add_class (context, "button");
- gtk_style_context_add_class (context, "default");
- }
- else if (strcmp (detail, "calendar") == 0)
- gtk_style_context_add_class (context, "calendar");
- else if (strcmp (detail, "cellcheck") == 0)
- {
- gtk_style_context_add_class (context, "cell");
- gtk_style_context_add_class (context, "check");
- }
- else if (strcmp (detail, "cellradio") == 0)
- {
- gtk_style_context_add_class (context, "cell");
- gtk_style_context_add_class (context, "radio");
- }
- else if (strcmp (detail, "checkbutton") == 0)
- gtk_style_context_add_class (context, "check");
- else if (strcmp (detail, "check") == 0)
- {
- gtk_style_context_add_class (context, "check");
- gtk_style_context_add_class (context, "menu");
- }
- else if (strcmp (detail, "radiobutton") == 0)
- {
- gtk_style_context_add_class (context, "radio");
- }
- else if (strcmp (detail, "option") == 0)
- {
- gtk_style_context_add_class (context, "radio");
- gtk_style_context_add_class (context, "menu");
- }
- else if (strcmp (detail, "entry") == 0 ||
- strcmp (detail, "entry_bg") == 0)
- gtk_style_context_add_class (context, "entry");
- else if (strcmp (detail, "expander") == 0)
- gtk_style_context_add_class (context, "expander");
- else if (strcmp (detail, "tooltip") == 0)
- gtk_style_context_add_class (context, "tooltip");
- else if (strcmp (detail, "frame") == 0)
- gtk_style_context_add_class (context, "frame");
- else if (strcmp (detail, "scrolled_window") == 0)
- gtk_style_context_add_class (context, "scrolled-window");
- else if (strcmp (detail, "viewport") == 0 ||
- strcmp (detail, "viewportbin") == 0)
- gtk_style_context_add_class (context, "viewport");
- else if (strncmp (detail, "trough", 6) == 0)
- gtk_style_context_add_class (context, "trough");
- else if (strcmp (detail, "spinbutton") == 0)
- gtk_style_context_add_class (context, "spinbutton");
- else if (strcmp (detail, "spinbutton_up") == 0)
- {
- gtk_style_context_add_class (context, "spinbutton");
- gtk_style_context_add_class (context, "button");
- gtk_style_context_set_junction_sides (context, GTK_JUNCTION_BOTTOM);
- }
- else if (strcmp (detail, "spinbutton_down") == 0)
- {
- gtk_style_context_add_class (context, "spinbutton");
- gtk_style_context_add_class (context, "button");
- gtk_style_context_set_junction_sides (context, GTK_JUNCTION_TOP);
- }
- else if ((detail[0] == 'h' || detail[0] == 'v') &&
- strncmp (&detail[1], "scrollbar_", 10) == 0)
- {
- gtk_style_context_add_class (context, "button");
- gtk_style_context_add_class (context, "scrollbar");
- }
- else if (strcmp (detail, "slider") == 0)
- {
- gtk_style_context_add_class (context, "slider");
- gtk_style_context_add_class (context, "scrollbar");
- }
- else if (strcmp (detail, "vscale") == 0 ||
- strcmp (detail, "hscale") == 0)
- {
- gtk_style_context_add_class (context, "slider");
- gtk_style_context_add_class (context, "scale");
- }
- else if (strcmp (detail, "menuitem") == 0)
- {
- gtk_style_context_add_class (context, "menuitem");
- gtk_style_context_add_class (context, "menu");
- }
- else if (strcmp (detail, "menu") == 0)
- {
- gtk_style_context_add_class (context, "popup");
- gtk_style_context_add_class (context, "menu");
- }
- else if (strcmp (detail, "accellabel") == 0)
- gtk_style_context_add_class (context, "accelerator");
- else if (strcmp (detail, "menubar") == 0)
- gtk_style_context_add_class (context, "menubar");
- else if (strcmp (detail, "base") == 0)
- gtk_style_context_add_class (context, "background");
- else if (strcmp (detail, "bar") == 0 ||
- strcmp (detail, "progressbar") == 0)
- gtk_style_context_add_class (context, "progressbar");
- else if (strcmp (detail, "toolbar") == 0)
- gtk_style_context_add_class (context, "toolbar");
- else if (strcmp (detail, "handlebox_bin") == 0)
- gtk_style_context_add_class (context, "dock");
- else if (strcmp (detail, "notebook") == 0)
- gtk_style_context_add_class (context, "notebook");
- else if (strcmp (detail, "tab") == 0)
- {
- gtk_style_context_add_class (context, "notebook");
- gtk_style_context_add_region (context, GTK_STYLE_REGION_TAB, 0);
- }
- else if (g_str_has_prefix (detail, "cell"))
- {
- GtkRegionFlags row, col;
- gboolean ruled = FALSE;
- GStrv tokens;
- guint i;
-
- tokens = g_strsplit (detail, "_", -1);
- row = col = 0;
- i = 0;
-
- while (tokens[i])
- {
- if (strcmp (tokens[i], "even") == 0)
- row |= GTK_REGION_EVEN;
- else if (strcmp (tokens[i], "odd") == 0)
- row |= GTK_REGION_ODD;
- else if (strcmp (tokens[i], "start") == 0)
- col |= GTK_REGION_FIRST;
- else if (strcmp (tokens[i], "end") == 0)
- col |= GTK_REGION_LAST;
- else if (strcmp (tokens[i], "ruled") == 0)
- ruled = TRUE;
- else if (strcmp (tokens[i], "sorted") == 0)
- col |= GTK_REGION_SORTED;
-
- i++;
- }
-
- if (!ruled)
- row &= ~(GTK_REGION_EVEN | GTK_REGION_ODD);
-
- gtk_style_context_add_class (context, "cell");
- gtk_style_context_add_region (context, "row", row);
- gtk_style_context_add_region (context, "column", col);
-
- g_strfreev (tokens);
- }
-}
-
-static void
-gtk_default_draw_hline (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x1,
- gint x2,
- gint y)
-{
- GtkStyleContext *context;
- GtkStylePrivate *priv;
-
- if (widget)
- context = gtk_widget_get_style_context (widget);
- else
- {
- priv = GTK_STYLE_GET_PRIVATE (style);
- context = priv->context;
- }
-
- gtk_style_context_save (context);
-
- if (detail)
- transform_detail_string (detail, context);
-
- cairo_save (cr);
-
- gtk_render_line (context, cr,
- x1, y, x2, y);
-
- cairo_restore (cr);
-
- gtk_style_context_restore (context);
-}
-
-
-static void
-gtk_default_draw_vline (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkWidget *widget,
- const gchar *detail,
- gint y1,
- gint y2,
- gint x)
-{
- GtkStyleContext *context;
- GtkStylePrivate *priv;
-
- if (widget)
- context = gtk_widget_get_style_context (widget);
- else
- {
- priv = GTK_STYLE_GET_PRIVATE (style);
- context = priv->context;
- }
-
- gtk_style_context_save (context);
-
- if (detail)
- transform_detail_string (detail, context);
-
- cairo_save (cr);
-
- gtk_render_line (context, cr,
- x, y1, x, y2);
-
- cairo_restore (cr);
- gtk_style_context_restore (context);
-}
-
-static void
-gtk_default_draw_shadow (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height)
-{
- GtkStyleContext *context;
- GtkStylePrivate *priv;
-
- if (shadow_type == GTK_SHADOW_NONE)
- return;
-
- if (widget)
- context = gtk_widget_get_style_context (widget);
- else
- {
- priv = GTK_STYLE_GET_PRIVATE (style);
- context = priv->context;
- }
-
- gtk_style_context_save (context);
-
- if (detail)
- transform_detail_string (detail, context);
-
- cairo_save (cr);
-
- gtk_render_frame (context, cr,
- (gdouble) x,
- (gdouble) y,
- (gdouble) width,
- (gdouble) height);
-
- cairo_restore (cr);
- gtk_style_context_restore (context);
-}
-
-static void
-draw_arrow (cairo_t *cr,
- GdkColor *color,
- GtkArrowType arrow_type,
- gint x,
- gint y,
- gint width,
- gint height)
-{
- gdk_cairo_set_source_color (cr, color);
- cairo_save (cr);
-
- if (arrow_type == GTK_ARROW_DOWN)
- {
- cairo_move_to (cr, x, y);
- cairo_line_to (cr, x + width, y);
- cairo_line_to (cr, x + width / 2., y + height);
- }
- else if (arrow_type == GTK_ARROW_UP)
- {
- cairo_move_to (cr, x, y + height);
- cairo_line_to (cr, x + width / 2., y);
- cairo_line_to (cr, x + width, y + height);
- }
- else if (arrow_type == GTK_ARROW_LEFT)
- {
- cairo_move_to (cr, x + width, y);
- cairo_line_to (cr, x + width, y + height);
- cairo_line_to (cr, x, y + height / 2.);
- }
- else if (arrow_type == GTK_ARROW_RIGHT)
- {
- cairo_move_to (cr, x, y);
- cairo_line_to (cr, x + width, y + height / 2.);
- cairo_line_to (cr, x, y + height);
- }
-
- cairo_close_path (cr);
- cairo_fill (cr);
-
- cairo_restore (cr);
-}
-
-static void
-gtk_default_draw_arrow (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state,
- GtkShadowType shadow,
- GtkWidget *widget,
- const gchar *detail,
- GtkArrowType arrow_type,
- gboolean fill,
- gint x,
- gint y,
- gint width,
- gint height)
-{
- GtkStyleContext *context;
- GtkStylePrivate *priv;
- GtkStateFlags flags = 0;
- gdouble angle, size;
-
- if (arrow_type == GTK_ARROW_NONE)
- return;
-
- if (widget)
- context = gtk_widget_get_style_context (widget);
- else
- {
- priv = GTK_STYLE_GET_PRIVATE (style);
- context = priv->context;
- }
-
- gtk_style_context_save (context);
-
- if (detail)
- transform_detail_string (detail, context);
-
- switch (arrow_type)
- {
- case GTK_ARROW_UP:
- angle = 0;
- size = width;
- break;
- case GTK_ARROW_RIGHT:
- angle = G_PI / 2;
- size = height;
- break;
- case GTK_ARROW_DOWN:
- angle = G_PI;
- size = width;
- break;
- case GTK_ARROW_LEFT:
- angle = 3 * (G_PI / 2);
- size = height;
- break;
- default:
- g_assert_not_reached ();
- }
-
- switch (state)
- {
- case GTK_STATE_PRELIGHT:
- flags |= GTK_STATE_FLAG_PRELIGHT;
- break;
- case GTK_STATE_SELECTED:
- flags |= GTK_STATE_FLAG_SELECTED;
- break;
- case GTK_STATE_INSENSITIVE:
- flags |= GTK_STATE_FLAG_INSENSITIVE;
- break;
- case GTK_STATE_ACTIVE:
- flags |= GTK_STATE_FLAG_ACTIVE;
- break;
- default:
- break;
- }
-
- gtk_style_context_set_state (context, flags);
-
- cairo_save (cr);
-
- gtk_render_arrow (context,
- cr, angle,
- (gdouble) x,
- (gdouble) y,
- size);
-
- cairo_restore (cr);
- gtk_style_context_restore (context);
-}
-
-static void
-gtk_default_draw_diamond (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height)
-{
- gint half_width;
- gint half_height;
- GdkColor *outer_nw = NULL;
- GdkColor *outer_ne = NULL;
- GdkColor *outer_sw = NULL;
- GdkColor *outer_se = NULL;
- GdkColor *middle_nw = NULL;
- GdkColor *middle_ne = NULL;
- GdkColor *middle_sw = NULL;
- GdkColor *middle_se = NULL;
- GdkColor *inner_nw = NULL;
- GdkColor *inner_ne = NULL;
- GdkColor *inner_sw = NULL;
- GdkColor *inner_se = NULL;
-
- half_width = width / 2;
- half_height = height / 2;
-
- switch (shadow_type)
- {
- case GTK_SHADOW_IN:
- inner_sw = inner_se = &style->bg[state_type];
- middle_sw = middle_se = &style->light[state_type];
- outer_sw = outer_se = &style->light[state_type];
- inner_nw = inner_ne = &style->black;
- middle_nw = middle_ne = &style->dark[state_type];
- outer_nw = outer_ne = &style->dark[state_type];
- break;
-
- case GTK_SHADOW_OUT:
- inner_sw = inner_se = &style->dark[state_type];
- middle_sw = middle_se = &style->dark[state_type];
- outer_sw = outer_se = &style->black;
- inner_nw = inner_ne = &style->bg[state_type];
- middle_nw = middle_ne = &style->light[state_type];
- outer_nw = outer_ne = &style->light[state_type];
- break;
-
- case GTK_SHADOW_ETCHED_IN:
- inner_sw = inner_se = &style->bg[state_type];
- middle_sw = middle_se = &style->dark[state_type];
- outer_sw = outer_se = &style->light[state_type];
- inner_nw = inner_ne = &style->bg[state_type];
- middle_nw = middle_ne = &style->light[state_type];
- outer_nw = outer_ne = &style->dark[state_type];
- break;
-
- case GTK_SHADOW_ETCHED_OUT:
- inner_sw = inner_se = &style->bg[state_type];
- middle_sw = middle_se = &style->light[state_type];
- outer_sw = outer_se = &style->dark[state_type];
- inner_nw = inner_ne = &style->bg[state_type];
- middle_nw = middle_ne = &style->dark[state_type];
- outer_nw = outer_ne = &style->light[state_type];
- break;
-
- default:
-
- break;
- }
-
- if (inner_sw)
- {
- _cairo_draw_line (cr, inner_sw,
- x + 2, y + half_height,
- x + half_width, y + height - 2);
- _cairo_draw_line (cr, inner_se,
- x + half_width, y + height - 2,
- x + width - 2, y + half_height);
- _cairo_draw_line (cr, middle_sw,
- x + 1, y + half_height,
- x + half_width, y + height - 1);
- _cairo_draw_line (cr, middle_se,
- x + half_width, y + height - 1,
- x + width - 1, y + half_height);
- _cairo_draw_line (cr, outer_sw,
- x, y + half_height,
- x + half_width, y + height);
- _cairo_draw_line (cr, outer_se,
- x + half_width, y + height,
- x + width, y + half_height);
-
- _cairo_draw_line (cr, inner_nw,
- x + 2, y + half_height,
- x + half_width, y + 2);
- _cairo_draw_line (cr, inner_ne,
- x + half_width, y + 2,
- x + width - 2, y + half_height);
- _cairo_draw_line (cr, middle_nw,
- x + 1, y + half_height,
- x + half_width, y + 1);
- _cairo_draw_line (cr, middle_ne,
- x + half_width, y + 1,
- x + width - 1, y + half_height);
- _cairo_draw_line (cr, outer_nw,
- x, y + half_height,
- x + half_width, y);
- _cairo_draw_line (cr, outer_ne,
- x + half_width, y,
- x + width, y + half_height);
- }
-}
-
-static void
-option_menu_get_props (GtkWidget *widget,
- GtkRequisition *indicator_size,
- GtkBorder *indicator_spacing)
-{
- GtkRequisition *tmp_size = NULL;
- GtkBorder *tmp_spacing = NULL;
-
- if (tmp_size)
- {
- *indicator_size = *tmp_size;
- gtk_requisition_free (tmp_size);
- }
- else
- *indicator_size = default_option_indicator_size;
-
- if (tmp_spacing)
- {
- *indicator_spacing = *tmp_spacing;
- gtk_border_free (tmp_spacing);
- }
- else
- *indicator_spacing = default_option_indicator_spacing;
-}
-
-static void
-gtk_default_draw_box (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height)
-{
- GtkStyleContext *context;
- GtkStylePrivate *priv;
- GtkStateFlags flags = 0;
-
- if (widget)
- context = gtk_widget_get_style_context (widget);
- else
- {
- priv = GTK_STYLE_GET_PRIVATE (style);
- context = priv->context;
- }
-
- gtk_style_context_save (context);
-
- if (detail)
- transform_detail_string (detail, context);
-
- switch (state_type)
- {
- case GTK_STATE_ACTIVE:
- flags |= GTK_STATE_FLAG_ACTIVE;
- break;
- case GTK_STATE_PRELIGHT:
- flags |= GTK_STATE_FLAG_PRELIGHT;
- break;
- case GTK_STATE_SELECTED:
- flags |= GTK_STATE_FLAG_SELECTED;
- break;
- case GTK_STATE_INSENSITIVE:
- flags |= GTK_STATE_FLAG_INSENSITIVE;
- break;
- default:
- break;
- }
-
- if (shadow_type == GTK_SHADOW_IN)
- flags |= GTK_STATE_FLAG_ACTIVE;
-
- gtk_style_context_set_state (context, flags);
-
- cairo_save (cr);
-
- if (gtk_style_context_has_class (context, GTK_STYLE_CLASS_PROGRESSBAR))
- gtk_render_activity (context, cr, x, y, width, height);
- else
- {
- gtk_render_background (context, cr, x, y, width, height);
-
- if (shadow_type != GTK_SHADOW_NONE)
- gtk_render_frame (context, cr, x, y, width, height);
- }
-
- cairo_restore (cr);
- gtk_style_context_restore (context);
-}
-
-static void
-gtk_default_draw_flat_box (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height)
-{
- GtkStyleContext *context;
- GtkStylePrivate *priv;
- GtkStateFlags flags = 0;
-
- if (widget)
- context = gtk_widget_get_style_context (widget);
- else
- {
- priv = GTK_STYLE_GET_PRIVATE (style);
- context = priv->context;
- }
-
- gtk_style_context_save (context);
-
- if (detail)
- transform_detail_string (detail, context);
-
- switch (state_type)
- {
- case GTK_STATE_PRELIGHT:
- flags |= GTK_STATE_FLAG_PRELIGHT;
- break;
- case GTK_STATE_SELECTED:
- flags |= GTK_STATE_FLAG_SELECTED;
- break;
- case GTK_STATE_INSENSITIVE:
- flags |= GTK_STATE_FLAG_INSENSITIVE;
- break;
- case GTK_STATE_ACTIVE:
- flags |= GTK_STATE_FLAG_ACTIVE;
- break;
- case GTK_STATE_FOCUSED:
- flags |= GTK_STATE_FLAG_FOCUSED;
- break;
- default:
- break;
- }
-
- gtk_style_context_set_state (context, flags);
-
- cairo_save (cr);
-
- gtk_render_background (context, cr,
- (gdouble) x,
- (gdouble) y,
- (gdouble) width,
- (gdouble) height);
-
- cairo_restore (cr);
- gtk_style_context_restore (context);
-}
-
-static void
-gtk_default_draw_check (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height)
-{
- GtkStyleContext *context;
- GtkStylePrivate *priv;
- GtkStateFlags flags = 0;
-
- if (widget)
- context = gtk_widget_get_style_context (widget);
- else
- {
- priv = GTK_STYLE_GET_PRIVATE (style);
- context = priv->context;
- }
-
- gtk_style_context_save (context);
-
- if (detail)
- transform_detail_string (detail, context);
-
- switch (state_type)
- {
- case GTK_STATE_PRELIGHT:
- flags |= GTK_STATE_FLAG_PRELIGHT;
- break;
- case GTK_STATE_SELECTED:
- flags |= GTK_STATE_FLAG_SELECTED;
- break;
- case GTK_STATE_INSENSITIVE:
- flags |= GTK_STATE_FLAG_INSENSITIVE;
- break;
- default:
- break;
- }
-
- if (shadow_type == GTK_SHADOW_IN)
- flags |= GTK_STATE_FLAG_ACTIVE;
- else if (shadow_type == GTK_SHADOW_ETCHED_IN)
- flags |= GTK_STATE_FLAG_INCONSISTENT;
-
- gtk_style_context_set_state (context, flags);
-
- cairo_save (cr);
-
- gtk_render_check (context,
- cr, x, y,
- width, height);
-
- cairo_restore (cr);
- gtk_style_context_restore (context);
-}
-
-static void
-gtk_default_draw_option (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height)
-{
- GtkStyleContext *context;
- GtkStylePrivate *priv;
- GtkStateFlags flags = 0;
-
- if (widget)
- context = gtk_widget_get_style_context (widget);
- else
- {
- priv = GTK_STYLE_GET_PRIVATE (style);
- context = priv->context;
- }
-
- gtk_style_context_save (context);
-
- if (detail)
- transform_detail_string (detail, context);
-
- switch (state_type)
- {
- case GTK_STATE_PRELIGHT:
- flags |= GTK_STATE_FLAG_PRELIGHT;
- break;
- case GTK_STATE_SELECTED:
- flags |= GTK_STATE_FLAG_SELECTED;
- break;
- case GTK_STATE_INSENSITIVE:
- flags |= GTK_STATE_FLAG_INSENSITIVE;
- break;
- default:
- break;
- }
-
- if (shadow_type == GTK_SHADOW_IN)
- flags |= GTK_STATE_FLAG_ACTIVE;
- else if (shadow_type == GTK_SHADOW_ETCHED_IN)
- flags |= GTK_STATE_FLAG_INCONSISTENT;
-
- gtk_style_context_set_state (context, flags);
-
- cairo_save (cr);
- gtk_render_option (context, cr,
- (gdouble) x,
- (gdouble) y,
- (gdouble) width,
- (gdouble) height);
-
- cairo_restore (cr);
- gtk_style_context_restore (context);
-}
-
-static void
-gtk_default_draw_tab (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height)
-{
-#define ARROW_SPACE 4
-
- GtkRequisition indicator_size;
- GtkBorder indicator_spacing;
- gint arrow_height;
-
- option_menu_get_props (widget, &indicator_size, &indicator_spacing);
-
- indicator_size.width += (indicator_size.width % 2) - 1;
- arrow_height = indicator_size.width / 2 + 1;
-
- x += (width - indicator_size.width) / 2;
- y += (height - (2 * arrow_height + ARROW_SPACE)) / 2;
-
- if (state_type == GTK_STATE_INSENSITIVE)
- {
- draw_arrow (cr, &style->white,
- GTK_ARROW_UP, x + 1, y + 1,
- indicator_size.width, arrow_height);
-
- draw_arrow (cr, &style->white,
- GTK_ARROW_DOWN, x + 1, y + arrow_height + ARROW_SPACE + 1,
- indicator_size.width, arrow_height);
- }
-
- draw_arrow (cr, &style->fg[state_type],
- GTK_ARROW_UP, x, y,
- indicator_size.width, arrow_height);
-
-
- draw_arrow (cr, &style->fg[state_type],
- GTK_ARROW_DOWN, x, y + arrow_height + ARROW_SPACE,
- indicator_size.width, arrow_height);
-}
-
-static void
-gtk_default_draw_shadow_gap (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height,
- GtkPositionType gap_side,
- gint gap_x,
- gint gap_width)
-{
- GtkStyleContext *context;
- GtkStylePrivate *priv;
- GtkStateFlags flags = 0;
-
- if (shadow_type == GTK_SHADOW_NONE)
- return;
-
- if (widget)
- context = gtk_widget_get_style_context (widget);
- else
- {
- priv = GTK_STYLE_GET_PRIVATE (style);
- context = priv->context;
- }
-
- gtk_style_context_save (context);
-
- if (detail)
- transform_detail_string (detail, context);
-
- switch (state_type)
- {
- case GTK_STATE_ACTIVE:
- flags |= GTK_STATE_FLAG_ACTIVE;
- break;
- case GTK_STATE_PRELIGHT:
- flags |= GTK_STATE_FLAG_PRELIGHT;
- break;
- case GTK_STATE_SELECTED:
- flags |= GTK_STATE_FLAG_SELECTED;
- break;
- case GTK_STATE_INSENSITIVE:
- flags |= GTK_STATE_FLAG_INSENSITIVE;
- break;
- default:
- break;
- }
-
- gtk_style_context_set_state (context, flags);
-
- cairo_save (cr);
- gtk_render_frame_gap (context, cr,
- (gdouble) x,
- (gdouble) y,
- (gdouble) width,
- (gdouble) height,
- gap_side,
- (gdouble) gap_x,
- (gdouble) gap_x + gap_width);
-
- cairo_restore (cr);
- gtk_style_context_restore (context);
-}
-
-static void
-gtk_default_draw_box_gap (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height,
- GtkPositionType gap_side,
- gint gap_x,
- gint gap_width)
-{
- GtkStyleContext *context;
- GtkStylePrivate *priv;
- GtkStateFlags flags = 0;
-
- if (widget)
- context = gtk_widget_get_style_context (widget);
- else
- {
- priv = GTK_STYLE_GET_PRIVATE (style);
- context = priv->context;
- }
-
- gtk_style_context_save (context);
-
- if (detail)
- transform_detail_string (detail, context);
-
- switch (state_type)
- {
- case GTK_STATE_ACTIVE:
- flags |= GTK_STATE_FLAG_ACTIVE;
- break;
- case GTK_STATE_PRELIGHT:
- flags |= GTK_STATE_FLAG_PRELIGHT;
- break;
- case GTK_STATE_SELECTED:
- flags |= GTK_STATE_FLAG_SELECTED;
- break;
- case GTK_STATE_INSENSITIVE:
- flags |= GTK_STATE_FLAG_INSENSITIVE;
- break;
- default:
- break;
- }
-
- gtk_style_context_set_state (context, flags);
-
- cairo_save (cr);
- gtk_render_background (context, cr,
- (gdouble) x,
- (gdouble) y,
- (gdouble) width,
- (gdouble) height);
-
-
- if (shadow_type != GTK_SHADOW_NONE)
- gtk_render_frame_gap (context, cr,
- (gdouble) x,
- (gdouble) y,
- (gdouble) width,
- (gdouble) height,
- gap_side,
- (gdouble) gap_x,
- (gdouble) gap_x + gap_width);
-
- cairo_restore (cr);
- gtk_style_context_restore (context);
-}
-
-static void
-gtk_default_draw_extension (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height,
- GtkPositionType gap_side)
-{
- GtkStyleContext *context;
- GtkStylePrivate *priv;
- GtkStateFlags flags = 0;
-
- if (widget)
- context = gtk_widget_get_style_context (widget);
- else
- {
- priv = GTK_STYLE_GET_PRIVATE (style);
- context = priv->context;
- }
-
- gtk_style_context_save (context);
-
- if (detail)
- transform_detail_string (detail, context);
-
- switch (state_type)
- {
- case GTK_STATE_ACTIVE:
- flags |= GTK_STATE_FLAG_ACTIVE;
- break;
- case GTK_STATE_PRELIGHT:
- flags |= GTK_STATE_FLAG_PRELIGHT;
- break;
- case GTK_STATE_SELECTED:
- flags |= GTK_STATE_FLAG_SELECTED;
- break;
- case GTK_STATE_INSENSITIVE:
- flags |= GTK_STATE_FLAG_INSENSITIVE;
- break;
- default:
- break;
- }
-
- gtk_style_context_set_state (context, flags);
-
- cairo_save (cr);
-
- gtk_render_extension (context, cr,
- (gdouble) x,
- (gdouble) y,
- (gdouble) width,
- (gdouble) height,
- gap_side);
-
- cairo_restore (cr);
- gtk_style_context_restore (context);
-}
-
-static void
-gtk_default_draw_focus (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height)
-{
- GtkStyleContext *context;
- GtkStylePrivate *priv;
-
- if (widget)
- context = gtk_widget_get_style_context (widget);
- else
- {
- priv = GTK_STYLE_GET_PRIVATE (style);
- context = priv->context;
- }
-
- gtk_style_context_save (context);
-
- if (detail)
- transform_detail_string (detail, context);
-
- cairo_save (cr);
-
- gtk_render_focus (context, cr,
- (gdouble) x,
- (gdouble) y,
- (gdouble) width,
- (gdouble) height);
-
- cairo_restore (cr);
- gtk_style_context_restore (context);
-}
-
-static void
-gtk_default_draw_slider (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height,
- GtkOrientation orientation)
-{
- GtkStyleContext *context;
- GtkStylePrivate *priv;
- GtkStateFlags flags = 0;
-
- if (widget)
- context = gtk_widget_get_style_context (widget);
- else
- {
- priv = GTK_STYLE_GET_PRIVATE (style);
- context = priv->context;
- }
-
- gtk_style_context_save (context);
-
- if (detail)
- transform_detail_string (detail, context);
-
- switch (state_type)
- {
- case GTK_STATE_PRELIGHT:
- flags |= GTK_STATE_FLAG_PRELIGHT;
- break;
- case GTK_STATE_SELECTED:
- flags |= GTK_STATE_FLAG_SELECTED;
- break;
- case GTK_STATE_INSENSITIVE:
- flags |= GTK_STATE_FLAG_INSENSITIVE;
- break;
- default:
- break;
- }
-
- gtk_style_context_set_state (context, flags);
-
- cairo_save (cr);
-
- gtk_render_slider (context, cr, x, y, width, height, orientation);
-
- cairo_restore (cr);
- gtk_style_context_restore (context);
-}
-
-static void
-gtk_default_draw_handle (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height,
- GtkOrientation orientation)
-{
- GtkStyleContext *context;
- GtkStylePrivate *priv;
- GtkStateFlags flags = 0;
-
- if (widget)
- context = gtk_widget_get_style_context (widget);
- else
- {
- priv = GTK_STYLE_GET_PRIVATE (style);
- context = priv->context;
- }
-
- gtk_style_context_save (context);
-
- if (detail)
- transform_detail_string (detail, context);
-
- switch (state_type)
- {
- case GTK_STATE_PRELIGHT:
- flags |= GTK_STATE_FLAG_PRELIGHT;
- break;
- case GTK_STATE_SELECTED:
- flags |= GTK_STATE_FLAG_SELECTED;
- break;
- case GTK_STATE_INSENSITIVE:
- flags |= GTK_STATE_FLAG_INSENSITIVE;
- break;
- default:
- break;
- }
-
- gtk_style_context_set_state (context, flags);
-
- cairo_save (cr);
-
- gtk_render_handle (context, cr,
- (gdouble) x,
- (gdouble) y,
- (gdouble) width,
- (gdouble) height);
-
- cairo_restore (cr);
- gtk_style_context_restore (context);
-}
-
-static void
-gtk_default_draw_expander (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- GtkExpanderStyle expander_style)
-{
- GtkStyleContext *context;
- GtkStylePrivate *priv;
- GtkStateFlags flags = 0;
- gint size;
-
- if (widget)
- context = gtk_widget_get_style_context (widget);
- else
- {
- priv = GTK_STYLE_GET_PRIVATE (style);
- context = priv->context;
- }
-
- gtk_style_context_save (context);
-
- if (detail)
- transform_detail_string (detail, context);
-
- gtk_style_context_add_class (context, "expander");
-
- switch (state_type)
- {
- case GTK_STATE_PRELIGHT:
- flags |= GTK_STATE_FLAG_PRELIGHT;
- break;
- case GTK_STATE_SELECTED:
- flags |= GTK_STATE_FLAG_SELECTED;
- break;
- case GTK_STATE_INSENSITIVE:
- flags |= GTK_STATE_FLAG_INSENSITIVE;
- break;
- default:
- break;
- }
-
- if (widget &&
- gtk_widget_class_find_style_property (GTK_WIDGET_GET_CLASS (widget),
- "expander-size"))
- gtk_widget_style_get (widget, "expander-size", &size, NULL);
- else
- size = 12;
-
- if (expander_style == GTK_EXPANDER_EXPANDED)
- flags |= GTK_STATE_FLAG_ACTIVE;
-
- gtk_style_context_set_state (context, flags);
-
- cairo_save (cr);
-
- gtk_render_expander (context, cr,
- (gdouble) x - (size / 2),
- (gdouble) y - (size / 2),
- (gdouble) size,
- (gdouble) size);
-
- cairo_restore (cr);
- gtk_style_context_restore (context);
-}
-
-static void
-gtk_default_draw_layout (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- gboolean use_text,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- PangoLayout *layout)
-{
- GtkStyleContext *context;
- GtkStylePrivate *priv;
- GtkStateFlags flags = 0;
-
- if (widget)
- context = gtk_widget_get_style_context (widget);
- else
- {
- priv = GTK_STYLE_GET_PRIVATE (style);
- context = priv->context;
- }
-
- gtk_style_context_save (context);
-
- if (detail)
- transform_detail_string (detail, context);
-
- switch (state_type)
- {
- case GTK_STATE_PRELIGHT:
- flags |= GTK_STATE_FLAG_PRELIGHT;
- break;
- case GTK_STATE_SELECTED:
- flags |= GTK_STATE_FLAG_SELECTED;
- break;
- case GTK_STATE_INSENSITIVE:
- flags |= GTK_STATE_FLAG_INSENSITIVE;
- break;
- default:
- break;
- }
-
- gtk_style_context_set_state (context, flags);
-
- cairo_save (cr);
-
- gtk_render_layout (context, cr,
- (gdouble) x,
- (gdouble) y,
- layout);
-
- cairo_restore (cr);
- gtk_style_context_restore (context);
-}
-
-static void
-gtk_default_draw_resize_grip (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkWidget *widget,
- const gchar *detail,
- GdkWindowEdge edge,
- gint x,
- gint y,
- gint width,
- gint height)
-{
- GtkStyleContext *context;
- GtkStylePrivate *priv;
- GtkStateFlags flags = 0;
- GtkJunctionSides sides = 0;
-
- if (widget)
- context = gtk_widget_get_style_context (widget);
- else
- {
- priv = GTK_STYLE_GET_PRIVATE (style);
- context = priv->context;
- }
-
- gtk_style_context_save (context);
-
- if (detail)
- transform_detail_string (detail, context);
-
- gtk_style_context_add_class (context, "grip");
-
- switch (state_type)
- {
- case GTK_STATE_PRELIGHT:
- flags |= GTK_STATE_FLAG_PRELIGHT;
- break;
- case GTK_STATE_SELECTED:
- flags |= GTK_STATE_FLAG_SELECTED;
- break;
- case GTK_STATE_INSENSITIVE:
- flags |= GTK_STATE_FLAG_INSENSITIVE;
- break;
- default:
- break;
- }
-
- gtk_style_context_set_state (context, flags);
-
- switch (edge)
- {
- case GDK_WINDOW_EDGE_NORTH_WEST:
- sides = GTK_JUNCTION_CORNER_TOPLEFT;
- break;
- case GDK_WINDOW_EDGE_NORTH:
- sides = GTK_JUNCTION_TOP;
- break;
- case GDK_WINDOW_EDGE_NORTH_EAST:
- sides = GTK_JUNCTION_CORNER_TOPRIGHT;
- break;
- case GDK_WINDOW_EDGE_WEST:
- sides = GTK_JUNCTION_LEFT;
- break;
- case GDK_WINDOW_EDGE_EAST:
- sides = GTK_JUNCTION_RIGHT;
- break;
- case GDK_WINDOW_EDGE_SOUTH_WEST:
- sides = GTK_JUNCTION_CORNER_BOTTOMLEFT;
- break;
- case GDK_WINDOW_EDGE_SOUTH:
- sides = GTK_JUNCTION_BOTTOM;
- break;
- case GDK_WINDOW_EDGE_SOUTH_EAST:
- sides = GTK_JUNCTION_CORNER_BOTTOMRIGHT;
- break;
- }
-
- gtk_style_context_set_junction_sides (context, sides);
-
- cairo_save (cr);
-
- gtk_render_handle (context, cr,
- (gdouble) x,
- (gdouble) y,
- (gdouble) width,
- (gdouble) height);
-
- cairo_restore (cr);
- gtk_style_context_restore (context);
-}
-
-static void
-gtk_default_draw_spinner (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkWidget *widget,
- const gchar *detail,
- guint step,
- gint x,
- gint y,
- gint width,
- gint height)
-{
- GdkColor *color;
- guint num_steps;
- gdouble dx, dy;
- gdouble radius;
- gdouble half;
- gint i;
- guint real_step;
-
- num_steps = 12;
- real_step = step % num_steps;
-
- /* set a clip region for the expose event */
- cairo_rectangle (cr, x, y, width, height);
- cairo_clip (cr);
-
- cairo_translate (cr, x, y);
-
- /* draw clip region */
- cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
-
- color = &style->fg[state_type];
- dx = width / 2;
- dy = height / 2;
- radius = MIN (width / 2, height / 2);
- half = num_steps / 2;
-
- for (i = 0; i < num_steps; i++)
- {
- gint inset = 0.7 * radius;
-
- /* transparency is a function of time and intial value */
- gdouble t = (gdouble) ((i + num_steps - real_step)
- % num_steps) / num_steps;
-
- cairo_save (cr);
-
- cairo_set_source_rgba (cr,
- color->red / 65535.,
- color->green / 65535.,
- color->blue / 65535.,
- t);
-
- cairo_set_line_width (cr, 2.0);
- cairo_move_to (cr,
- dx + (radius - inset) * cos (i * G_PI / half),
- dy + (radius - inset) * sin (i * G_PI / half));
- cairo_line_to (cr,
- dx + radius * cos (i * G_PI / half),
- dy + radius * sin (i * G_PI / half));
- cairo_stroke (cr);
-
- cairo_restore (cr);
- }
-}
-
-void
-_gtk_style_shade (const GdkColor *a,
- GdkColor *b,
- gdouble k)
-{
- gdouble red;
- gdouble green;
- gdouble blue;
-
- red = (gdouble) a->red / 65535.0;
- green = (gdouble) a->green / 65535.0;
- blue = (gdouble) a->blue / 65535.0;
-
- rgb_to_hls (&red, &green, &blue);
-
- green *= k;
- if (green > 1.0)
- green = 1.0;
- else if (green < 0.0)
- green = 0.0;
-
- blue *= k;
- if (blue > 1.0)
- blue = 1.0;
- else if (blue < 0.0)
- blue = 0.0;
-
- hls_to_rgb (&red, &green, &blue);
-
- b->red = red * 65535.0;
- b->green = green * 65535.0;
- b->blue = blue * 65535.0;
-}
-
-static void
-rgb_to_hls (gdouble *r,
- gdouble *g,
- gdouble *b)
-{
- gdouble min;
- gdouble max;
- gdouble red;
- gdouble green;
- gdouble blue;
- gdouble h, l, s;
- gdouble delta;
-
- red = *r;
- green = *g;
- blue = *b;
-
- if (red > green)
- {
- if (red > blue)
- max = red;
- else
- max = blue;
-
- if (green < blue)
- min = green;
- else
- min = blue;
- }
- else
- {
- if (green > blue)
- max = green;
- else
- max = blue;
-
- if (red < blue)
- min = red;
- else
- min = blue;
- }
-
- l = (max + min) / 2;
- s = 0;
- h = 0;
-
- if (max != min)
- {
- if (l <= 0.5)
- s = (max - min) / (max + min);
- else
- s = (max - min) / (2 - max - min);
-
- delta = max -min;
- if (red == max)
- h = (green - blue) / delta;
- else if (green == max)
- h = 2 + (blue - red) / delta;
- else if (blue == max)
- h = 4 + (red - green) / delta;
-
- h *= 60;
- if (h < 0.0)
- h += 360;
- }
-
- *r = h;
- *g = l;
- *b = s;
-}
-
-static void
-hls_to_rgb (gdouble *h,
- gdouble *l,
- gdouble *s)
-{
- gdouble hue;
- gdouble lightness;
- gdouble saturation;
- gdouble m1, m2;
- gdouble r, g, b;
-
- lightness = *l;
- saturation = *s;
-
- if (lightness <= 0.5)
- m2 = lightness * (1 + saturation);
- else
- m2 = lightness + saturation - lightness * saturation;
- m1 = 2 * lightness - m2;
-
- if (saturation == 0)
- {
- *h = lightness;
- *l = lightness;
- *s = lightness;
- }
- else
- {
- hue = *h + 120;
- while (hue > 360)
- hue -= 360;
- while (hue < 0)
- hue += 360;
-
- if (hue < 60)
- r = m1 + (m2 - m1) * hue / 60;
- else if (hue < 180)
- r = m2;
- else if (hue < 240)
- r = m1 + (m2 - m1) * (240 - hue) / 60;
- else
- r = m1;
-
- hue = *h;
- while (hue > 360)
- hue -= 360;
- while (hue < 0)
- hue += 360;
-
- if (hue < 60)
- g = m1 + (m2 - m1) * hue / 60;
- else if (hue < 180)
- g = m2;
- else if (hue < 240)
- g = m1 + (m2 - m1) * (240 - hue) / 60;
- else
- g = m1;
-
- hue = *h - 120;
- while (hue > 360)
- hue -= 360;
- while (hue < 0)
- hue += 360;
-
- if (hue < 60)
- b = m1 + (m2 - m1) * hue / 60;
- else if (hue < 180)
- b = m2;
- else if (hue < 240)
- b = m1 + (m2 - m1) * (240 - hue) / 60;
- else
- b = m1;
-
- *h = r;
- *l = g;
- *s = b;
- }
-}
-
-
-/**
- * gtk_paint_hline:
- * @style: a #GtkStyle
- * @cr: a #caio_t
- * @state_type: a state
- * @widget: (allow-none): the widget
- * @detail: (allow-none): a style detail
- * @x1: the starting x coordinate
- * @x2: the ending x coordinate
- * @y: the y coordinate
- *
- * Draws a horizontal line from (@x1, @y) to (@x2, @y) in @cr
- * using the given style and state.
- *
- * Deprecated:3.0: Use gtk_render_line() instead
- **/
-void
-gtk_paint_hline (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x1,
- gint x2,
- gint y)
-{
- g_return_if_fail (GTK_IS_STYLE (style));
- g_return_if_fail (cr != NULL);
- g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_hline != NULL);
-
- cairo_save (cr);
-
- GTK_STYLE_GET_CLASS (style)->draw_hline (style, cr, state_type,
- widget, detail,
- x1, x2, y);
-
- cairo_restore (cr);
-}
-
-/**
- * gtk_paint_vline:
- * @style: a #GtkStyle
- * @cr: a #cairo_t
- * @state_type: a state
- * @widget: (allow-none): the widget
- * @detail: (allow-none): a style detail
- * @y1_: the starting y coordinate
- * @y2_: the ending y coordinate
- * @x: the x coordinate
- *
- * Draws a vertical line from (@x, @y1_) to (@x, @y2_) in @cr
- * using the given style and state.
- *
- * Deprecated:3.0: Use gtk_render_line() instead
- */
-void
-gtk_paint_vline (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkWidget *widget,
- const gchar *detail,
- gint y1_,
- gint y2_,
- gint x)
-{
- g_return_if_fail (GTK_IS_STYLE (style));
- g_return_if_fail (cr != NULL);
- g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_vline != NULL);
-
- cairo_save (cr);
-
- GTK_STYLE_GET_CLASS (style)->draw_vline (style, cr, state_type,
- widget, detail,
- y1_, y2_, x);
-
- cairo_restore (cr);
-}
-
-/**
- * gtk_paint_shadow:
- * @style: a #GtkStyle
- * @cr: a #cairo_t
- * @state_type: a state
- * @shadow_type: type of shadow to draw
- * @widget: (allow-none): the widget
- * @detail: (allow-none): a style detail
- * @x: x origin of the rectangle
- * @y: y origin of the rectangle
- * @width: width of the rectangle
- * @height: width of the rectangle
- *
- * Draws a shadow around the given rectangle in @cr
- * using the given style and state and shadow type.
- *
- * Deprecated:3.0: Use gtk_render_frame() instead
- */
-void
-gtk_paint_shadow (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height)
-{
- g_return_if_fail (GTK_IS_STYLE (style));
- g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_shadow != NULL);
- g_return_if_fail (cr != NULL);
- g_return_if_fail (width >= 0);
- g_return_if_fail (height >= 0);
-
- cairo_save (cr);
-
- GTK_STYLE_GET_CLASS (style)->draw_shadow (style, cr, state_type, shadow_type,
- widget, detail,
- x, y, width, height);
-
- cairo_restore (cr);
-}
-
-/**
- * gtk_paint_arrow:
- * @style: a #GtkStyle
- * @cr: a #cairo_t
- * @state_type: a state
- * @shadow_type: the type of shadow to draw
- * @widget: (allow-none): the widget
- * @detail: (allow-none): a style detail
- * @arrow_type: the type of arrow to draw
- * @fill: %TRUE if the arrow tip should be filled
- * @x: x origin of the rectangle to draw the arrow in
- * @y: y origin of the rectangle to draw the arrow in
- * @width: width of the rectangle to draw the arrow in
- * @height: height of the rectangle to draw the arrow in
- *
- * Draws an arrow in the given rectangle on @cr using the given
- * parameters. @arrow_type determines the direction of the arrow.
- *
- * Deprecated:3.0: Use gtk_render_arrow() instead
- */
-void
-gtk_paint_arrow (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- GtkArrowType arrow_type,
- gboolean fill,
- gint x,
- gint y,
- gint width,
- gint height)
-{
- g_return_if_fail (GTK_IS_STYLE (style));
- g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_arrow != NULL);
- g_return_if_fail (cr != NULL);
- g_return_if_fail (width >= 0);
- g_return_if_fail (height >= 0);
-
- cairo_save (cr);
-
- GTK_STYLE_GET_CLASS (style)->draw_arrow (style, cr, state_type, shadow_type,
- widget, detail,
- arrow_type, fill, x, y, width, height);
-
- cairo_restore (cr);
-}
-
-/**
- * gtk_paint_diamond:
- * @style: a #GtkStyle
- * @cr: a #cairo_t
- * @state_type: a state
- * @shadow_type: the type of shadow to draw
- * @widget: (allow-none): the widget
- * @detail: (allow-none): a style detail
- * @x: x origin of the rectangle to draw the diamond in
- * @y: y origin of the rectangle to draw the diamond in
- * @width: width of the rectangle to draw the diamond in
- * @height: height of the rectangle to draw the diamond in
- *
- * Draws a diamond in the given rectangle on @window using the given
- * parameters.
- *
- * Deprecated:3.0: Use cairo instead
- */
-void
-gtk_paint_diamond (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height)
-{
- g_return_if_fail (GTK_IS_STYLE (style));
- g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_diamond != NULL);
- g_return_if_fail (cr != NULL);
- g_return_if_fail (width >= 0);
- g_return_if_fail (height >= 0);
-
- cairo_save (cr);
-
- GTK_STYLE_GET_CLASS (style)->draw_diamond (style, cr, state_type, shadow_type,
- widget, detail,
- x, y, width, height);
-
- cairo_restore (cr);
-}
-
-/**
- * gtk_paint_box:
- * @style: a #GtkStyle
- * @cr: a #cairo_t
- * @state_type: a state
- * @shadow_type: the type of shadow to draw
- * @widget: (allow-none): the widget
- * @detail: (allow-none): a style detail
- * @x: x origin of the box
- * @y: y origin of the box
- * @width: the width of the box
- * @height: the height of the box
- *
- * Draws a box on @cr with the given parameters.
- *
- * Deprecated:3.0: Use gtk_render_frame() and gtk_render_background() instead
- */
-void
-gtk_paint_box (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height)
-{
- g_return_if_fail (GTK_IS_STYLE (style));
- g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_box != NULL);
- g_return_if_fail (cr != NULL);
-
- cairo_save (cr);
-
- GTK_STYLE_GET_CLASS (style)->draw_box (style, cr, state_type, shadow_type,
- widget, detail,
- x, y, width, height);
-
- cairo_restore (cr);
-}
-
-/**
- * gtk_paint_flat_box:
- * @style: a #GtkStyle
- * @cr: a #cairo_t
- * @state_type: a state
- * @shadow_type: the type of shadow to draw
- * @widget: (allow-none): the widget
- * @detail: (allow-none): a style detail
- * @x: x origin of the box
- * @y: y origin of the box
- * @width: the width of the box
- * @height: the height of the box
- *
- * Draws a flat box on @cr with the given parameters.
- *
- * Deprecated:3.0: Use gtk_render_frame() and gtk_render_background() instead
- */
-void
-gtk_paint_flat_box (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height)
-{
- g_return_if_fail (GTK_IS_STYLE (style));
- g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_flat_box != NULL);
- g_return_if_fail (cr != NULL);
- g_return_if_fail (width >= 0);
- g_return_if_fail (height >= 0);
-
- cairo_save (cr);
-
- GTK_STYLE_GET_CLASS (style)->draw_flat_box (style, cr, state_type, shadow_type,
- widget, detail,
- x, y, width, height);
-
- cairo_restore (cr);
-}
-
-/**
- * gtk_paint_check:
- * @style: a #GtkStyle
- * @cr: a #cairo_t
- * @state_type: a state
- * @shadow_type: the type of shadow to draw
- * @widget: (allow-none): the widget
- * @detail: (allow-none): a style detail
- * @x: x origin of the rectangle to draw the check in
- * @y: y origin of the rectangle to draw the check in
- * @width: the width of the rectangle to draw the check in
- * @height: the height of the rectangle to draw the check in
- *
- * Draws a check button indicator in the given rectangle on @cr with
- * the given parameters.
- *
- * Deprecated:3.0: Use gtk_render_check() instead
- */
-void
-gtk_paint_check (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height)
-{
- g_return_if_fail (GTK_IS_STYLE (style));
- g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_check != NULL);
- g_return_if_fail (cr != NULL);
-
- cairo_save (cr);
-
- GTK_STYLE_GET_CLASS (style)->draw_check (style, cr, state_type, shadow_type,
- widget, detail,
- x, y, width, height);
-
- cairo_restore (cr);
-}
-
-/**
- * gtk_paint_option:
- * @style: a #GtkStyle
- * @cr: a #cairo_t
- * @state_type: a state
- * @shadow_type: the type of shadow to draw
- * @widget: (allow-none): the widget
- * @detail: (allow-none): a style detail
- * @x: x origin of the rectangle to draw the option in
- * @y: y origin of the rectangle to draw the option in
- * @width: the width of the rectangle to draw the option in
- * @height: the height of the rectangle to draw the option in
- *
- * Draws a radio button indicator in the given rectangle on @cr with
- * the given parameters.
- *
- * Deprecated:3.0: Use gtk_render_option() instead
- */
-void
-gtk_paint_option (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height)
-{
- g_return_if_fail (GTK_IS_STYLE (style));
- g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_option != NULL);
- g_return_if_fail (cr != NULL);
-
- cairo_save (cr);
-
- GTK_STYLE_GET_CLASS (style)->draw_option (style, cr, state_type, shadow_type,
- widget, detail,
- x, y, width, height);
-
- cairo_restore (cr);
-}
-
-/**
- * gtk_paint_tab:
- * @style: a #GtkStyle
- * @cr: a #cairo_t
- * @state_type: a state
- * @shadow_type: the type of shadow to draw
- * @widget: (allow-none): the widget
- * @detail: (allow-none): a style detail
- * @x: x origin of the rectangle to draw the tab in
- * @y: y origin of the rectangle to draw the tab in
- * @width: the width of the rectangle to draw the tab in
- * @height: the height of the rectangle to draw the tab in
- *
- * Draws an option menu tab (i.e. the up and down pointing arrows)
- * in the given rectangle on @cr using the given parameters.
- *
- * Deprecated:3.0: Use cairo instead
- */
-void
-gtk_paint_tab (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height)
-{
- g_return_if_fail (GTK_IS_STYLE (style));
- g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_tab != NULL);
- g_return_if_fail (cr != NULL);
-
- cairo_save (cr);
-
- GTK_STYLE_GET_CLASS (style)->draw_tab (style, cr, state_type, shadow_type,
- widget, detail,
- x, y, width, height);
-
- cairo_restore (cr);
-}
-
-/**
- * gtk_paint_shadow_gap:
- * @style: a #GtkStyle
- * @cr: a #cairo_t
- * @state_type: a state
- * @shadow_type: type of shadow to draw
- * @widget: (allow-none): the widget
- * @detail: (allow-none): a style detail
- * @x: x origin of the rectangle
- * @y: y origin of the rectangle
- * @width: width of the rectangle
- * @height: width of the rectangle
- * @gap_side: side in which to leave the gap
- * @gap_x: starting position of the gap
- * @gap_width: width of the gap
- *
- * Draws a shadow around the given rectangle in @cr
- * using the given style and state and shadow type, leaving a
- * gap in one side.
- *
- * Deprecated:3.0: Use gtk_render_frame_gap() instead
- */
-void
-gtk_paint_shadow_gap (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height,
- GtkPositionType gap_side,
- gint gap_x,
- gint gap_width)
-{
- g_return_if_fail (GTK_IS_STYLE (style));
- g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_shadow_gap != NULL);
- g_return_if_fail (cr != NULL);
- g_return_if_fail (width >= 0);
- g_return_if_fail (height >= 0);
-
- cairo_save (cr);
-
- GTK_STYLE_GET_CLASS (style)->draw_shadow_gap (style, cr, state_type, shadow_type,
- widget, detail,
- x, y, width, height, gap_side, gap_x, gap_width);
-
- cairo_restore (cr);
-}
-
-/**
- * gtk_paint_box_gap:
- * @style: a #GtkStyle
- * @cr: a #cairo_t
- * @state_type: a state
- * @shadow_type: type of shadow to draw
- * @widget: (allow-none): the widget
- * @detail: (allow-none): a style detail
- * @x: x origin of the rectangle
- * @y: y origin of the rectangle
- * @width: width of the rectangle
- * @height: width of the rectangle
- * @gap_side: side in which to leave the gap
- * @gap_x: starting position of the gap
- * @gap_width: width of the gap
- *
- * Draws a box in @cr using the given style and state and shadow type,
- * leaving a gap in one side.
- *
- * Deprecated:3.0: Use gtk_render_frame_gap() instead
- */
-void
-gtk_paint_box_gap (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height,
- GtkPositionType gap_side,
- gint gap_x,
- gint gap_width)
-{
- g_return_if_fail (GTK_IS_STYLE (style));
- g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_box_gap != NULL);
- g_return_if_fail (cr != NULL);
- g_return_if_fail (width >= 0);
- g_return_if_fail (height >= 0);
-
- cairo_save (cr);
-
- GTK_STYLE_GET_CLASS (style)->draw_box_gap (style, cr, state_type, shadow_type,
- widget, detail,
- x, y, width, height, gap_side, gap_x, gap_width);
-
- cairo_restore (cr);
-}
-
-/**
- * gtk_paint_extension:
- * @style: a #GtkStyle
- * @cr: a #cairo_t
- * @state_type: a state
- * @shadow_type: type of shadow to draw
- * @widget: (allow-none): the widget
- * @detail: (allow-none): a style detail
- * @x: x origin of the extension
- * @y: y origin of the extension
- * @width: width of the extension
- * @height: width of the extension
- * @gap_side: the side on to which the extension is attached
- *
- * Draws an extension, i.e. a notebook tab.
- *
- * Deprecated:3.0: Use gtk_render_extension() instead
- **/
-void
-gtk_paint_extension (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height,
- GtkPositionType gap_side)
-{
- g_return_if_fail (GTK_IS_STYLE (style));
- g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_extension != NULL);
- g_return_if_fail (cr != NULL);
- g_return_if_fail (width >= 0);
- g_return_if_fail (height >= 0);
-
- cairo_save (cr);
-
- GTK_STYLE_GET_CLASS (style)->draw_extension (style, cr, state_type, shadow_type,
- widget, detail,
- x, y, width, height, gap_side);
-
- cairo_restore (cr);
-}
-
-/**
- * gtk_paint_focus:
- * @style: a #GtkStyle
- * @cr: a #cairo_t
- * @state_type: a state
- * @widget: (allow-none): the widget
- * @detail: (allow-none): a style detail
- * @x: the x origin of the rectangle around which to draw a focus indicator
- * @y: the y origin of the rectangle around which to draw a focus indicator
- * @width: the width of the rectangle around which to draw a focus indicator
- * @height: the height of the rectangle around which to draw a focus indicator
- *
- * Draws a focus indicator around the given rectangle on @cr using the
- * given style.
- *
- * Deprecated:3.0: Use gtk_render_focus() instead
- */
-void
-gtk_paint_focus (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height)
-{
- g_return_if_fail (GTK_IS_STYLE (style));
- g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_focus != NULL);
- g_return_if_fail (cr != NULL);
- g_return_if_fail (width >= 0);
- g_return_if_fail (height >= 0);
-
- cairo_save (cr);
-
- GTK_STYLE_GET_CLASS (style)->draw_focus (style, cr, state_type,
- widget, detail,
- x, y, width, height);
-
- cairo_restore (cr);
-}
-
-/**
- * gtk_paint_slider:
- * @style: a #GtkStyle
- * @cr: a #cairo_t
- * @state_type: a state
- * @shadow_type: a shadow
- * @widget: (allow-none): the widget
- * @detail: (allow-none): a style detail
- * @x: the x origin of the rectangle in which to draw a slider
- * @y: the y origin of the rectangle in which to draw a slider
- * @width: the width of the rectangle in which to draw a slider
- * @height: the height of the rectangle in which to draw a slider
- * @orientation: the orientation to be used
- *
- * Draws a slider in the given rectangle on @cr using the
- * given style and orientation.
- *
- * Deprecated:3.0: Use gtk_render_slider() instead
- **/
-void
-gtk_paint_slider (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height,
- GtkOrientation orientation)
-{
- g_return_if_fail (GTK_IS_STYLE (style));
- g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_slider != NULL);
- g_return_if_fail (cr != NULL);
- g_return_if_fail (width >= 0);
- g_return_if_fail (height >= 0);
-
- cairo_save (cr);
-
- GTK_STYLE_GET_CLASS (style)->draw_slider (style, cr, state_type, shadow_type,
- widget, detail,
- x, y, width, height, orientation);
-
- cairo_restore (cr);
-}
-
-/**
- * gtk_paint_handle:
- * @style: a #GtkStyle
- * @cr: a #cairo_t
- * @state_type: a state
- * @shadow_type: type of shadow to draw
- * @widget: (allow-none): the widget
- * @detail: (allow-none): a style detail
- * @x: x origin of the handle
- * @y: y origin of the handle
- * @width: with of the handle
- * @height: height of the handle
- * @orientation: the orientation of the handle
- *
- * Draws a handle as used in #GtkHandleBox and #GtkPaned.
- *
- * Deprecated:3.0: Use gtk_render_handle() instead
- **/
-void
-gtk_paint_handle (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height,
- GtkOrientation orientation)
-{
- g_return_if_fail (GTK_IS_STYLE (style));
- g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_handle != NULL);
- g_return_if_fail (cr != NULL);
- g_return_if_fail (width >= 0);
- g_return_if_fail (height >= 0);
-
- cairo_save (cr);
-
- GTK_STYLE_GET_CLASS (style)->draw_handle (style, cr, state_type, shadow_type,
- widget, detail,
- x, y, width, height, orientation);
-
- cairo_restore (cr);
-}
-
-/**
- * gtk_paint_expander:
- * @style: a #GtkStyle
- * @cr: a #cairo_t
- * @state_type: a state
- * @widget: (allow-none): the widget
- * @detail: (allow-none): a style detail
- * @x: the x position to draw the expander at
- * @y: the y position to draw the expander at
- * @expander_style: the style to draw the expander in; determines
- * whether the expander is collapsed, expanded, or in an
- * intermediate state.
- *
- * Draws an expander as used in #GtkTreeView. @x and @y specify the
- * center the expander. The size of the expander is determined by the
- * "expander-size" style property of @widget. (If widget is not
- * specified or doesn't have an "expander-size" property, an
- * unspecified default size will be used, since the caller doesn't
- * have sufficient information to position the expander, this is
- * likely not useful.) The expander is expander_size pixels tall
- * in the collapsed position and expander_size pixels wide in the
- * expanded position.
- *
- * Deprecated:3.0: Use gtk_render_expander() instead
- **/
-void
-gtk_paint_expander (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- GtkExpanderStyle expander_style)
-{
- g_return_if_fail (GTK_IS_STYLE (style));
- g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_expander != NULL);
- g_return_if_fail (cr != NULL);
-
- cairo_save (cr);
-
- GTK_STYLE_GET_CLASS (style)->draw_expander (style, cr, state_type,
- widget, detail,
- x, y, expander_style);
-
- cairo_restore (cr);
-}
-
-/**
- * gtk_paint_layout:
- * @style: a #GtkStyle
- * @cr: a #cairo_t
- * @state_type: a state
- * @use_text: whether to use the text or foreground
- * graphics context of @style
- * @widget: (allow-none): the widget
- * @detail: (allow-none): a style detail
- * @x: x origin
- * @y: y origin
- * @layout: the layout to draw
- *
- * Draws a layout on @cr using the given parameters.
- *
- * Deprecated:3.0: Use gtk_render_layout() instead
- **/
-void
-gtk_paint_layout (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- gboolean use_text,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- PangoLayout *layout)
-{
- g_return_if_fail (GTK_IS_STYLE (style));
- g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_layout != NULL);
- g_return_if_fail (cr != NULL);
-
- cairo_save (cr);
-
- GTK_STYLE_GET_CLASS (style)->draw_layout (style, cr, state_type, use_text,
- widget, detail,
- x, y, layout);
-
- cairo_restore (cr);
-}
-
-/**
- * gtk_paint_resize_grip:
- * @style: a #GtkStyle
- * @cr: a #cairo_t
- * @state_type: a state
- * @widget: (allow-none): the widget
- * @detail: (allow-none): a style detail
- * @edge: the edge in which to draw the resize grip
- * @x: the x origin of the rectangle in which to draw the resize grip
- * @y: the y origin of the rectangle in which to draw the resize grip
- * @width: the width of the rectangle in which to draw the resize grip
- * @height: the height of the rectangle in which to draw the resize grip
- *
- * Draws a resize grip in the given rectangle on @cr using the given
- * parameters.
- *
- * Deprecated:3.0: Use gtk_render_handle() instead
- */
-void
-gtk_paint_resize_grip (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkWidget *widget,
- const gchar *detail,
- GdkWindowEdge edge,
- gint x,
- gint y,
- gint width,
- gint height)
-{
- g_return_if_fail (GTK_IS_STYLE (style));
- g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_resize_grip != NULL);
- g_return_if_fail (cr != NULL);
-
- cairo_save (cr);
-
- GTK_STYLE_GET_CLASS (style)->draw_resize_grip (style, cr, state_type,
- widget, detail,
- edge, x, y, width, height);
- cairo_restore (cr);
-}
-
-/**
- * gtk_paint_spinner:
- * @style: a #GtkStyle
- * @cr: a #cairo_t
- * @state_type: a state
- * @widget: (allow-none): the widget (may be %NULL)
- * @detail: (allow-none): a style detail (may be %NULL)
- * @step: the nth step, a value between 0 and #GtkSpinner:num-steps
- * @x: the x origin of the rectangle in which to draw the spinner
- * @y: the y origin of the rectangle in which to draw the spinner
- * @width: the width of the rectangle in which to draw the spinner
- * @height: the height of the rectangle in which to draw the spinner
- *
- * Draws a spinner on @window using the given parameters.
- *
- * Deprecated:3.0: Use gtk_render_activity() instead
- */
-void
-gtk_paint_spinner (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkWidget *widget,
- const gchar *detail,
- guint step,
- gint x,
- gint y,
- gint width,
- gint height)
-{
- g_return_if_fail (GTK_IS_STYLE (style));
- g_return_if_fail (cr != NULL);
- g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_spinner != NULL);
-
- cairo_save (cr);
-
- GTK_STYLE_GET_CLASS (style)->draw_spinner (style, cr, state_type,
- widget, detail,
- step, x, y, width, height);
-
- cairo_restore (cr);
-}
+++ /dev/null
-/* GTK - The GIMP Toolkit
- * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
- */
-
-/*
- * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
- * file for a list of people on the GTK+ Team. See the ChangeLog
- * files for a list of changes. These files are distributed with
- * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
- */
-
-#if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
-#error "Only <gtk/gtk.h> can be included directly."
-#endif
-
-#ifndef __GTK_STYLE_H__
-#define __GTK_STYLE_H__
-
-
-#include <gdk/gdk.h>
-#include <gtk/gtkenums.h>
-#include <gtk/gtkwidgetpath.h>
-
-
-G_BEGIN_DECLS
-
-#define GTK_TYPE_STYLE (gtk_style_get_type ())
-#define GTK_STYLE(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GTK_TYPE_STYLE, GtkStyle))
-#define GTK_STYLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_STYLE, GtkStyleClass))
-#define GTK_IS_STYLE(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GTK_TYPE_STYLE))
-#define GTK_IS_STYLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_STYLE))
-#define GTK_STYLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_STYLE, GtkStyleClass))
-
-/* Some forward declarations needed to rationalize the header
- * files.
- */
-typedef struct _GtkStyle GtkStyle;
-typedef struct _GtkStyleClass GtkStyleClass;
-typedef struct _GtkThemeEngine GtkThemeEngine;
-typedef struct _GtkRcStyle GtkRcStyle;
-typedef struct _GtkIconSet GtkIconSet;
-typedef struct _GtkIconSource GtkIconSource;
-typedef struct _GtkRcProperty GtkRcProperty;
-typedef struct _GtkSettings GtkSettings;
-typedef gboolean (*GtkRcPropertyParser) (const GParamSpec *pspec,
- const GString *rc_string,
- GValue *property_value);
-
-/**
- * GTK_STYLE_ATTACHED:
- * @style: a #GtkStyle.
- *
- * Returns whether the style is attached to a window.
- */
-#define GTK_STYLE_ATTACHED(style) (GTK_STYLE (style)->attach_count > 0)
-
-struct _GtkStyle
-{
- GObject parent_instance;
-
- /*< public >*/
-
- GdkColor fg[5];
- GdkColor bg[5];
- GdkColor light[5];
- GdkColor dark[5];
- GdkColor mid[5];
- GdkColor text[5];
- GdkColor base[5];
- GdkColor text_aa[5]; /* Halfway between text/base */
-
- GdkColor black;
- GdkColor white;
- PangoFontDescription *font_desc;
-
- gint xthickness;
- gint ythickness;
-
- cairo_pattern_t *background[5];
-
- /*< private >*/
-
- gint attach_count;
-
- GdkVisual *visual;
- PangoFontDescription *private_font_desc; /* Font description for style->private_font or %NULL */
-
- /* the RcStyle from which this style was created */
- GtkRcStyle *rc_style;
-
- GSList *styles; /* of type GtkStyle* */
- GArray *property_cache;
- GSList *icon_factories; /* of type GtkIconFactory* */
-};
-
-struct _GtkStyleClass
-{
- GObjectClass parent_class;
-
- /* Initialize for a particular visual. style->visual
- * will have been set at this point. Will typically chain
- * to parent.
- */
- void (*realize) (GtkStyle *style);
-
- /* Clean up for a particular visual. Will typically chain
- * to parent.
- */
- void (*unrealize) (GtkStyle *style);
-
- /* Make style an exact duplicate of src.
- */
- void (*copy) (GtkStyle *style,
- GtkStyle *src);
-
- /* Create an empty style of the same type as this style.
- * The default implementation, which does
- * g_object_new (G_OBJECT_TYPE (style), NULL);
- * should work in most cases.
- */
- GtkStyle *(*clone) (GtkStyle *style);
-
- /* Initialize the GtkStyle with the values in the GtkRcStyle.
- * should chain to the parent implementation.
- */
- void (*init_from_rc) (GtkStyle *style,
- GtkRcStyle *rc_style);
-
- void (*set_background) (GtkStyle *style,
- GdkWindow *window,
- GtkStateType state_type);
-
-
- GdkPixbuf * (* render_icon) (GtkStyle *style,
- const GtkIconSource *source,
- GtkTextDirection direction,
- GtkStateType state,
- GtkIconSize size,
- GtkWidget *widget,
- const gchar *detail);
-
- /* Drawing functions
- */
-
- void (*draw_hline) (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x1,
- gint x2,
- gint y);
- void (*draw_vline) (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkWidget *widget,
- const gchar *detail,
- gint y1_,
- gint y2_,
- gint x);
- void (*draw_shadow) (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height);
- void (*draw_arrow) (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- GtkArrowType arrow_type,
- gboolean fill,
- gint x,
- gint y,
- gint width,
- gint height);
- void (*draw_diamond) (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height);
- void (*draw_box) (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height);
- void (*draw_flat_box) (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height);
- void (*draw_check) (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height);
- void (*draw_option) (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height);
- void (*draw_tab) (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height);
- void (*draw_shadow_gap) (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height,
- GtkPositionType gap_side,
- gint gap_x,
- gint gap_width);
- void (*draw_box_gap) (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height,
- GtkPositionType gap_side,
- gint gap_x,
- gint gap_width);
- void (*draw_extension) (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height,
- GtkPositionType gap_side);
- void (*draw_focus) (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height);
- void (*draw_slider) (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height,
- GtkOrientation orientation);
- void (*draw_handle) (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height,
- GtkOrientation orientation);
-
- void (*draw_expander) (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- GtkExpanderStyle expander_style);
- void (*draw_layout) (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- gboolean use_text,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- PangoLayout *layout);
- void (*draw_resize_grip) (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkWidget *widget,
- const gchar *detail,
- GdkWindowEdge edge,
- gint x,
- gint y,
- gint width,
- gint height);
- void (*draw_spinner) (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkWidget *widget,
- const gchar *detail,
- guint step,
- gint x,
- gint y,
- gint width,
- gint height);
-
- /* Padding for future expansion */
- void (*_gtk_reserved1) (void);
- void (*_gtk_reserved2) (void);
- void (*_gtk_reserved3) (void);
- void (*_gtk_reserved4) (void);
- void (*_gtk_reserved5) (void);
- void (*_gtk_reserved6) (void);
- void (*_gtk_reserved7) (void);
- void (*_gtk_reserved8) (void);
- void (*_gtk_reserved9) (void);
- void (*_gtk_reserved10) (void);
- void (*_gtk_reserved11) (void);
-};
-
-#if !defined(GTK_DISABLE_DEPRECATED) || defined(GTK_COMPILATION)
-
-GType gtk_style_get_type (void) G_GNUC_CONST;
-GDK_DEPRECATED_FOR(GtkStyleContext)
-GtkStyle* gtk_style_new (void);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-GtkStyle* gtk_style_copy (GtkStyle *style);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-GtkStyle* gtk_style_attach (GtkStyle *style,
- GdkWindow *window);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-void gtk_style_detach (GtkStyle *style);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-void gtk_style_set_background (GtkStyle *style,
- GdkWindow *window,
- GtkStateType state_type);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-void gtk_style_apply_default_background (GtkStyle *style,
- cairo_t *cr,
- GdkWindow *window,
- GtkStateType state_type,
- gint x,
- gint y,
- gint width,
- gint height);
-
-GDK_DEPRECATED_FOR(GtkStyleContext)
-GtkIconSet* gtk_style_lookup_icon_set (GtkStyle *style,
- const gchar *stock_id);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-gboolean gtk_style_lookup_color (GtkStyle *style,
- const gchar *color_name,
- GdkColor *color);
-
-GDK_DEPRECATED_FOR(GtkStyleContext)
-GdkPixbuf* gtk_style_render_icon (GtkStyle *style,
- const GtkIconSource *source,
- GtkTextDirection direction,
- GtkStateType state,
- GtkIconSize size,
- GtkWidget *widget,
- const gchar *detail);
-
-GDK_DEPRECATED_FOR(GtkStyleContext)
-void gtk_paint_hline (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x1,
- gint x2,
- gint y);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-void gtk_paint_vline (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkWidget *widget,
- const gchar *detail,
- gint y1_,
- gint y2_,
- gint x);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-void gtk_paint_shadow (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-void gtk_paint_arrow (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- GtkArrowType arrow_type,
- gboolean fill,
- gint x,
- gint y,
- gint width,
- gint height);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-void gtk_paint_diamond (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-void gtk_paint_box (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-void gtk_paint_flat_box (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-void gtk_paint_check (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-void gtk_paint_option (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-void gtk_paint_tab (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-void gtk_paint_shadow_gap (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height,
- GtkPositionType gap_side,
- gint gap_x,
- gint gap_width);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-void gtk_paint_box_gap (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height,
- GtkPositionType gap_side,
- gint gap_x,
- gint gap_width);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-void gtk_paint_extension (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height,
- GtkPositionType gap_side);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-void gtk_paint_focus (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-void gtk_paint_slider (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height,
- GtkOrientation orientation);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-void gtk_paint_handle (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkShadowType shadow_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- gint width,
- gint height,
- GtkOrientation orientation);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-void gtk_paint_expander (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- GtkExpanderStyle expander_style);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-void gtk_paint_layout (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- gboolean use_text,
- GtkWidget *widget,
- const gchar *detail,
- gint x,
- gint y,
- PangoLayout *layout);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-void gtk_paint_resize_grip (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkWidget *widget,
- const gchar *detail,
- GdkWindowEdge edge,
- gint x,
- gint y,
- gint width,
- gint height);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-void gtk_paint_spinner (GtkStyle *style,
- cairo_t *cr,
- GtkStateType state_type,
- GtkWidget *widget,
- const gchar *detail,
- guint step,
- gint x,
- gint y,
- gint width,
- gint height);
-
-GDK_DEPRECATED_FOR(GtkStyleContext)
-void gtk_style_get_style_property (GtkStyle *style,
- GType widget_type,
- const gchar *property_name,
- GValue *value);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-void gtk_style_get_valist (GtkStyle *style,
- GType widget_type,
- const gchar *first_property_name,
- va_list var_args);
-GDK_DEPRECATED_FOR(GtkStyleContext)
-void gtk_style_get (GtkStyle *style,
- GType widget_type,
- const gchar *first_property_name,
- ...) G_GNUC_NULL_TERMINATED;
-
-#endif
-
-/* --- private API --- */
-GtkStyle* _gtk_style_new_for_path (GdkScreen *screen,
- GtkWidgetPath *path);
-void _gtk_style_shade (const GdkColor *a,
- GdkColor *b,
- gdouble k);
-
-gboolean gtk_style_has_context (GtkStyle *style);
-
-
-
-G_END_DECLS
-
-#endif /* __GTK_STYLE_H__ */
#define __GTK_STYLE_PROVIDER_H__
#include <glib-object.h>
-#include "gtkwidgetpath.h"
-#include "gtkiconfactory.h"
-#include "gtkstyleproperties.h"
-#include "gtkenums.h"
+#include <gtk/gtkwidgetpath.h>
+#include <gtk/gtkiconfactory.h>
+#include <gtk/gtkstyleproperties.h>
+#include <gtk/gtkenums.h>
G_BEGIN_DECLS
#include <gtk/gtkx.h>
#include "gtkspinbutton.h"
+#include "gtkmain.h"
+#include "gtkbox.h"
+#include "gtklabel.h"
+#include "gtkbutton.h"
+#include "gtktextview.h"
+#include "gtkrange.h"
#include <locale.h>
#include <string.h>
#include <gdk/gdk.h>
#include <gtk/gtkaccelgroup.h>
#include <gtk/gtkadjustment.h>
-#include <gtk/gtkstyle.h>
#include <gtk/gtkborder.h>
#include <gtk/gtksettings.h>
#include <gtk/gtkstylecontext.h>
typedef struct _GtkTooltip GtkTooltip;
typedef struct _GtkWindow GtkWindow;
-
/**
* GtkAllocation:
* @x: the X position of the widget's area relative to its parents allocation.
void gtk_widget_reset_style (GtkWidget *widget);
-#if !defined(GTK_DISABLE_DEPRECATED) || defined(GTK_COMPILATION)
+#ifndef GTK_DISABLE_DEPRECATED
void gtk_widget_style_attach (GtkWidget *widget);
-I$(top_srcdir) \
-I$(top_builddir)/gdk \
-I$(top_srcdir)/gdk \
- -DGDK_DISABLE_DEPRECATED \
- -DGTK_DISABLE_DEPRECATED \
-DSRCDIR=\""$(abs_srcdir)"\" \
$(GTK_DEBUG_FLAGS) \
$(GTK_DEP_CFLAGS)
projects / gtk4.git / commitdiff